Phase 3 complete: managed assembler
task 3.5-3.6: x86 stdcall/thiscall/fastcall stubs (8 tests) task 3.7-3.8: x64 stub with RCX/RDX/R8/R9 register args + stack push (4 tests) task 3.9: no-FASM reference assertion test All passing (total: 87).
This commit is contained in:
@@ -110,9 +110,52 @@ public class StubAssembler : IAssembler
|
||||
buffer.Add(0xC3); // ret
|
||||
}
|
||||
|
||||
private static void BuildX64Stub(List<byte> buffer, ulong stubAddr,
|
||||
private void BuildX64Stub(List<byte> buffer, ulong stubAddr,
|
||||
ulong target, uint[] args)
|
||||
{
|
||||
throw new NotImplementedException("x64 stubs (task 3.7-3.8)");
|
||||
ulong current = stubAddr;
|
||||
|
||||
// First 4 args go in RCX, RDX, R8D, R9D
|
||||
var regCodes = new byte[] { 0xB9, 0xBA, 0xB8, 0xB9 }; // mov ecx/r8d/edx/r9d, imm32
|
||||
var rexBytes = new byte[] { 0x00, 0x00, 0x41, 0x41 }; // 0x00 = no REX, 0x41 = REX.B
|
||||
|
||||
int regCount = Math.Min(args.Length, 4);
|
||||
for (int i = 0; i < regCount; i++)
|
||||
{
|
||||
if (rexBytes[i] != 0)
|
||||
buffer.Add(rexBytes[i]);
|
||||
buffer.Add(regCodes[i]);
|
||||
EmitU32(buffer, args[i]);
|
||||
current += (rexBytes[i] != 0 ? 6u : 5u);
|
||||
}
|
||||
|
||||
// Push remaining args in reverse order (right-to-left)
|
||||
for (int i = args.Length - 1; i >= 4; i--)
|
||||
{
|
||||
buffer.Add(0x68); // push imm32
|
||||
EmitU32(buffer, args[i]);
|
||||
current += 5;
|
||||
}
|
||||
|
||||
// call rel32
|
||||
uint rel32 = (uint)(target - (current + 5));
|
||||
buffer.Add(0xE8);
|
||||
EmitU32(buffer, rel32);
|
||||
|
||||
// Caller cleanup: pop any args pushed on stack
|
||||
int stackArgs = args.Length > 4 ? args.Length - 4 : 0;
|
||||
if (stackArgs > 0)
|
||||
{
|
||||
int bytes = stackArgs * 8;
|
||||
buffer.Add(0x48); // REX.W
|
||||
buffer.Add(bytes <= 127 ? (byte)0x83 : (byte)0x81); // add r/m64, imm8/imm32
|
||||
buffer.Add(0xC4); // rsp
|
||||
if (bytes <= 127)
|
||||
buffer.Add((byte)bytes);
|
||||
else
|
||||
EmitU32(buffer, (uint)bytes);
|
||||
}
|
||||
|
||||
buffer.Add(0xC3); // ret
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,234 +8,173 @@ public class StubAssemblerTests
|
||||
|
||||
// ── Emit primitives ────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void EmitU8_appends_a_single_byte()
|
||||
{
|
||||
var sut = Create();
|
||||
var buffer = new List<byte>();
|
||||
sut.EmitU8(buffer, 0xAB);
|
||||
Assert.Equal([0xAB], buffer);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EmitU32_appends_little_endian()
|
||||
{
|
||||
var sut = Create();
|
||||
var buffer = new List<byte>();
|
||||
sut.EmitU32(buffer, 0x11223344);
|
||||
Assert.Equal([0x44, 0x33, 0x22, 0x11], buffer);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EmitU32_appends_zero()
|
||||
{
|
||||
var sut = Create();
|
||||
var buffer = new List<byte>();
|
||||
sut.EmitU32(buffer, 0);
|
||||
Assert.Equal([0x00, 0x00, 0x00, 0x00], buffer);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EmitU64_appends_little_endian()
|
||||
{
|
||||
var sut = Create();
|
||||
var buffer = new List<byte>();
|
||||
sut.EmitU64(buffer, 0x1122334455667788);
|
||||
byte[] expected = [0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11];
|
||||
Assert.Equal(expected, buffer);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EmitU64_appends_high_bits()
|
||||
{
|
||||
var sut = Create();
|
||||
var buffer = new List<byte>();
|
||||
sut.EmitU64(buffer, 0xDEADBEEF_CAFEBABE);
|
||||
byte[] expected = [0xBE, 0xBA, 0xFE, 0xCA, 0xEF, 0xBE, 0xAD, 0xDE];
|
||||
Assert.Equal(expected, buffer);
|
||||
}
|
||||
|
||||
// ── IAssembler interface ───────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void StubAssembler_is_an_IAssembler()
|
||||
{
|
||||
var sut = Create();
|
||||
Assert.IsAssignableFrom<IAssembler>(sut);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Assemble_from_StubAssembler_throws_NotSupported()
|
||||
{
|
||||
var sut = Create();
|
||||
Assert.Throws<NotSupportedException>(() => sut.Assemble("nop", 0));
|
||||
}
|
||||
[Fact] public void EmitU8_appends_a_single_byte() { var s=Create(); var b=new List<byte>(); s.EmitU8(b,0xAB); Assert.Equal([0xAB],b); }
|
||||
[Fact] public void EmitU32_appends_little_endian() { var s=Create(); var b=new List<byte>(); s.EmitU32(b,0x11223344); Assert.Equal([0x44,0x33,0x22,0x11],b); }
|
||||
[Fact] public void EmitU32_appends_zero() { var s=Create(); var b=new List<byte>(); s.EmitU32(b,0); Assert.Equal([0,0,0,0],b); }
|
||||
[Fact] public void EmitU64_appends_little_endian() { var s=Create(); var b=new List<byte>(); s.EmitU64(b,0x1122334455667788); Assert.Equal([0x88,0x77,0x66,0x55,0x44,0x33,0x22,0x11],b); }
|
||||
[Fact] public void EmitU64_appends_high_bits() { var s=Create(); var b=new List<byte>(); s.EmitU64(b,0xDEADBEEF_CAFEBABE); Assert.Equal([0xBE,0xBA,0xFE,0xCA,0xEF,0xBE,0xAD,0xDE],b); }
|
||||
[Fact] public void StubAssembler_is_IAssembler() { Assert.IsAssignableFrom<IAssembler>(Create()); }
|
||||
[Fact] public void Assemble_throws() { Assert.Throws<NotSupportedException>(()=>Create().Assemble("nop",0)); }
|
||||
|
||||
// ── x86 cdecl ──────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Cdecl_stub_zero_args_call_then_ret()
|
||||
public void Cdecl_0args()
|
||||
{
|
||||
var sut = Create();
|
||||
uint rel32 = 0x12345678u - (0x10000000u + 5);
|
||||
byte[] stub = sut.BuildCallStub(
|
||||
(IntPtr)0x10000000, (IntPtr)0x12345678, [], 4, CallingConvention.Cdecl);
|
||||
|
||||
Assert.Equal([0xE8, (byte)rel32, (byte)(rel32>>8), (byte)(rel32>>16), (byte)(rel32>>24), 0xC3], stub);
|
||||
uint r = 0x12345678u-(0x10000000u+5);
|
||||
Assert.Equal([0xE8,(byte)r,(byte)(r>>8),(byte)(r>>16),(byte)(r>>24),0xC3],
|
||||
Create().BuildCallStub((IntPtr)0x10000000,(IntPtr)0x12345678,[],4,CallingConvention.Cdecl));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Cdecl_stub_one_arg_push_call_cleanup_ret()
|
||||
public void Cdecl_1arg()
|
||||
{
|
||||
var sut = Create();
|
||||
uint callAddr = 0x10000000u + 5;
|
||||
uint rel32 = 0x12345678u - (callAddr + 5);
|
||||
byte[] stub = sut.BuildCallStub(
|
||||
(IntPtr)0x10000000, (IntPtr)0x12345678, [0xAABBCCDD], 4, CallingConvention.Cdecl);
|
||||
|
||||
uint ca=0x10000000u+5,r=0x12345678u-(ca+5);
|
||||
Assert.Equal([
|
||||
0x68, 0xDD, 0xCC, 0xBB, 0xAA,
|
||||
0xE8, (byte)rel32, (byte)(rel32>>8), (byte)(rel32>>16), (byte)(rel32>>24),
|
||||
0x83, 0xC4, 0x04,
|
||||
0xC3
|
||||
], stub);
|
||||
0x68,0xDD,0xCC,0xBB,0xAA,
|
||||
0xE8,(byte)r,(byte)(r>>8),(byte)(r>>16),(byte)(r>>24),
|
||||
0x83,0xC4,0x04,0xC3],
|
||||
Create().BuildCallStub((IntPtr)0x10000000,(IntPtr)0x12345678,[0xAABBCCDD],4,CallingConvention.Cdecl));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Cdecl_stub_two_args_reverse_order()
|
||||
public void Cdecl_2args()
|
||||
{
|
||||
var sut = Create();
|
||||
uint callAddr = 0x10000000u + 10;
|
||||
uint rel32 = 0x12345678u - (callAddr + 5);
|
||||
byte[] stub = sut.BuildCallStub(
|
||||
(IntPtr)0x10000000, (IntPtr)0x12345678, [0x11111111, 0x22222222], 4, CallingConvention.Cdecl);
|
||||
|
||||
uint ca=0x10000000u+10,r=0x12345678u-(ca+5);
|
||||
Assert.Equal([
|
||||
0x68, 0x22, 0x22, 0x22, 0x22,
|
||||
0x68, 0x11, 0x11, 0x11, 0x11,
|
||||
0xE8, (byte)rel32, (byte)(rel32>>8), (byte)(rel32>>16), (byte)(rel32>>24),
|
||||
0x83, 0xC4, 0x08,
|
||||
0xC3
|
||||
], stub);
|
||||
0x68,0x22,0x22,0x22,0x22,
|
||||
0x68,0x11,0x11,0x11,0x11,
|
||||
0xE8,(byte)r,(byte)(r>>8),(byte)(r>>16),(byte)(r>>24),
|
||||
0x83,0xC4,0x08,0xC3],
|
||||
Create().BuildCallStub((IntPtr)0x10000000,(IntPtr)0x12345678,[0x11111111,0x22222222],4,CallingConvention.Cdecl));
|
||||
}
|
||||
|
||||
// ── x86 stdcall ────────────────────────────────────────────────────────
|
||||
// ── x86 stdcall ──────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Stdcall_stub_one_arg_no_cleanup()
|
||||
public void Stdcall_1arg()
|
||||
{
|
||||
var sut = Create();
|
||||
uint callAddr = 0x10000000u + 5;
|
||||
uint rel32 = 0x12345678u - (callAddr + 5);
|
||||
byte[] stub = sut.BuildCallStub(
|
||||
(IntPtr)0x10000000, (IntPtr)0x12345678, [0xAABBCCDD], 4, CallingConvention.Stdcall);
|
||||
|
||||
uint ca=0x10000000u+5,r=0x12345678u-(ca+5);
|
||||
Assert.Equal([
|
||||
0x68, 0xDD, 0xCC, 0xBB, 0xAA,
|
||||
0xE8, (byte)rel32, (byte)(rel32>>8), (byte)(rel32>>16), (byte)(rel32>>24),
|
||||
0xC3
|
||||
], stub);
|
||||
0x68,0xDD,0xCC,0xBB,0xAA,
|
||||
0xE8,(byte)r,(byte)(r>>8),(byte)(r>>16),(byte)(r>>24),0xC3],
|
||||
Create().BuildCallStub((IntPtr)0x10000000,(IntPtr)0x12345678,[0xAABBCCDD],4,CallingConvention.Stdcall));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Stdcall_stub_two_args_reverse_no_cleanup()
|
||||
public void Stdcall_2args()
|
||||
{
|
||||
var sut = Create();
|
||||
uint callAddr = 0x10000000u + 10;
|
||||
uint rel32 = 0x12345678u - (callAddr + 5);
|
||||
byte[] stub = sut.BuildCallStub(
|
||||
(IntPtr)0x10000000, (IntPtr)0x12345678, [0x11111111, 0x22222222], 4, CallingConvention.Stdcall);
|
||||
|
||||
uint ca=0x10000000u+10,r=0x12345678u-(ca+5);
|
||||
Assert.Equal([
|
||||
0x68, 0x22, 0x22, 0x22, 0x22,
|
||||
0x68, 0x11, 0x11, 0x11, 0x11,
|
||||
0xE8, (byte)rel32, (byte)(rel32>>8), (byte)(rel32>>16), (byte)(rel32>>24),
|
||||
0xC3
|
||||
], stub);
|
||||
0x68,0x22,0x22,0x22,0x22,
|
||||
0x68,0x11,0x11,0x11,0x11,
|
||||
0xE8,(byte)r,(byte)(r>>8),(byte)(r>>16),(byte)(r>>24),0xC3],
|
||||
Create().BuildCallStub((IntPtr)0x10000000,(IntPtr)0x12345678,[0x11111111,0x22222222],4,CallingConvention.Stdcall));
|
||||
}
|
||||
|
||||
// ── x86 thiscall ───────────────────────────────────────────────────────
|
||||
// ── x86 thiscall ─────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Thiscall_stub_ecx_then_stack_then_call()
|
||||
public void Thiscall_ecx_then_stack()
|
||||
{
|
||||
var sut = Create();
|
||||
uint callAddr = 0x10000000u + 10;
|
||||
uint rel32 = 0x12345678u - (callAddr + 5);
|
||||
byte[] stub = sut.BuildCallStub(
|
||||
(IntPtr)0x10000000, (IntPtr)0x12345678, [0xAAAA5555, 0xBBBB6666], 4, CallingConvention.Thiscall);
|
||||
|
||||
uint ca=0x10000000u+10,r=0x12345678u-(ca+5);
|
||||
Assert.Equal([
|
||||
0xB9, 0x55, 0x55, 0xAA, 0xAA,
|
||||
0x68, 0x66, 0x66, 0xBB, 0xBB,
|
||||
0xE8, (byte)rel32, (byte)(rel32>>8), (byte)(rel32>>16), (byte)(rel32>>24),
|
||||
0xC3
|
||||
], stub);
|
||||
0xB9,0x55,0x55,0xAA,0xAA,
|
||||
0x68,0x66,0x66,0xBB,0xBB,
|
||||
0xE8,(byte)r,(byte)(r>>8),(byte)(r>>16),(byte)(r>>24),0xC3],
|
||||
Create().BuildCallStub((IntPtr)0x10000000,(IntPtr)0x12345678,[0xAAAA5555,0xBBBB6666],4,CallingConvention.Thiscall));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Thiscall_stub_one_arg_ecx_only_then_call()
|
||||
public void Thiscall_1arg()
|
||||
{
|
||||
var sut = Create();
|
||||
uint callAddr = 0x10000000u + 5;
|
||||
uint rel32 = 0x12345678u - (callAddr + 5);
|
||||
byte[] stub = sut.BuildCallStub(
|
||||
(IntPtr)0x10000000, (IntPtr)0x12345678, [0xCAFEBABE], 4, CallingConvention.Thiscall);
|
||||
|
||||
Assert.Equal(11, stub.Length);
|
||||
Assert.Equal(0xB9, stub[0]);
|
||||
Assert.Equal(0xCAFEBABE, BitConverter.ToUInt32(stub, 1));
|
||||
Assert.Equal(0xE8, stub[5]);
|
||||
Assert.Equal(rel32, BitConverter.ToUInt32(stub, 6));
|
||||
Assert.Equal(0xC3, stub[10]);
|
||||
uint ca=0x10000000u+5,r=0x12345678u-(ca+5);
|
||||
byte[] s=Create().BuildCallStub((IntPtr)0x10000000,(IntPtr)0x12345678,[0xCAFEBABE],4,CallingConvention.Thiscall);
|
||||
Assert.Equal(11,s.Length); Assert.Equal(0xB9,s[0]); Assert.Equal(0xCAFEBABE,BitConverter.ToUInt32(s,1));
|
||||
Assert.Equal(0xE8,s[5]); Assert.Equal(r,BitConverter.ToUInt32(s,6)); Assert.Equal(0xC3,s[10]);
|
||||
}
|
||||
|
||||
// ── x86 fastcall ───────────────────────────────────────────────────────
|
||||
// ── x86 fastcall ────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Fastcall_stub_ecx_edx_stack_call()
|
||||
public void Fastcall_ecx_edx_stack()
|
||||
{
|
||||
var sut = Create();
|
||||
uint callAddr = 0x10000000u + 15;
|
||||
uint rel32 = 0x12345678u - (callAddr + 5);
|
||||
byte[] stub = sut.BuildCallStub(
|
||||
(IntPtr)0x10000000, (IntPtr)0x12345678, [0x11111111, 0x22222222, 0x33333333], 4, CallingConvention.Fastcall);
|
||||
|
||||
uint ca=0x10000000u+15,r=0x12345678u-(ca+5);
|
||||
Assert.Equal([
|
||||
0xB9, 0x11, 0x11, 0x11, 0x11,
|
||||
0xBA, 0x22, 0x22, 0x22, 0x22,
|
||||
0x68, 0x33, 0x33, 0x33, 0x33,
|
||||
0xE8, (byte)rel32, (byte)(rel32>>8), (byte)(rel32>>16), (byte)(rel32>>24),
|
||||
0xC3
|
||||
], stub);
|
||||
0xB9,0x11,0x11,0x11,0x11,
|
||||
0xBA,0x22,0x22,0x22,0x22,
|
||||
0x68,0x33,0x33,0x33,0x33,
|
||||
0xE8,(byte)r,(byte)(r>>8),(byte)(r>>16),(byte)(r>>24),0xC3],
|
||||
Create().BuildCallStub((IntPtr)0x10000000,(IntPtr)0x12345678,[0x11111111,0x22222222,0x33333333],4,CallingConvention.Fastcall));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Fastcall_stub_two_args_registers_only()
|
||||
public void Fastcall_2args()
|
||||
{
|
||||
var sut = Create();
|
||||
uint callAddr = 0x10000000u + 10;
|
||||
uint rel32 = 0x12345678u - (callAddr + 5);
|
||||
byte[] stub = sut.BuildCallStub(
|
||||
(IntPtr)0x10000000, (IntPtr)0x12345678, [0xAAAAAAAA, 0xBBBBBBBB], 4, CallingConvention.Fastcall);
|
||||
|
||||
Assert.Equal(16, stub.Length);
|
||||
Assert.Equal(0xB9, stub[0]);
|
||||
Assert.Equal(0xAAAAAAAA, BitConverter.ToUInt32(stub, 1));
|
||||
Assert.Equal(0xBA, stub[5]);
|
||||
Assert.Equal(0xBBBBBBBB, BitConverter.ToUInt32(stub, 6));
|
||||
Assert.Equal(0xE8, stub[10]);
|
||||
Assert.Equal(rel32, BitConverter.ToUInt32(stub, 11));
|
||||
Assert.Equal(0xC3, stub[15]);
|
||||
uint ca=0x10000000u+10,r=0x12345678u-(ca+5);
|
||||
byte[] s=Create().BuildCallStub((IntPtr)0x10000000,(IntPtr)0x12345678,[0xAAAAAAAA,0xBBBBBBBB],4,CallingConvention.Fastcall);
|
||||
Assert.Equal(16,s.Length); Assert.Equal(0xB9,s[0]); Assert.Equal(0xAAAAAAAA,BitConverter.ToUInt32(s,1));
|
||||
Assert.Equal(0xBA,s[5]); Assert.Equal(0xBBBBBBBB,BitConverter.ToUInt32(s,6));
|
||||
Assert.Equal(0xE8,s[10]); Assert.Equal(r,BitConverter.ToUInt32(s,11)); Assert.Equal(0xC3,s[15]);
|
||||
}
|
||||
|
||||
// ── x64 ────────────────────────────────────────────────────────────────
|
||||
// ── x64 ─────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void X64_stub_throws_not_implemented_by_default()
|
||||
public void X64_0args()
|
||||
{
|
||||
var sut = Create();
|
||||
Assert.Throws<NotImplementedException>(() =>
|
||||
sut.BuildCallStub((IntPtr)0x10000000, (IntPtr)0x12345678, [], 8, CallingConvention.Cdecl));
|
||||
var s=Create(); ulong a=0x100000000,t=0x123456788;
|
||||
uint r=(uint)(t-(a+5));
|
||||
byte[] stub=s.BuildCallStub((IntPtr)(nint)a,(IntPtr)(nint)t,[],8,CallingConvention.Cdecl);
|
||||
Assert.Equal(6,stub.Length); Assert.Equal(0xE8,stub[0]); Assert.Equal(r,BitConverter.ToUInt32(stub,1)); Assert.Equal(0xC3,stub[5]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void X64_1arg_mov_ecx()
|
||||
{
|
||||
var s=Create(); ulong a=0x100000000,t=0x123456788;
|
||||
uint r=(uint)(t-(a+5+5));
|
||||
Assert.Equal([
|
||||
0xB9,0xDD,0xCC,0xBB,0xAA,
|
||||
0xE8,(byte)r,(byte)(r>>8),(byte)(r>>16),(byte)(r>>24),0xC3],
|
||||
s.BuildCallStub((IntPtr)(nint)a,(IntPtr)(nint)t,[0xAABBCCDD],8,CallingConvention.Cdecl));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void X64_4args_rcx_rdx_r8_r9()
|
||||
{
|
||||
var s=Create(); ulong a=0x100000000,t=0x123456788;
|
||||
uint ca=(uint)a+5+5+6+6,r=(uint)(t-(ca+5));
|
||||
Assert.Equal([
|
||||
0xB9,0x11,0x11,0x11,0x11, 0xBA,0x22,0x22,0x22,0x22,
|
||||
0x41,0xB8,0x33,0x33,0x33,0x33, 0x41,0xB9,0x44,0x44,0x44,0x44,
|
||||
0xE8,(byte)r,(byte)(r>>8),(byte)(r>>16),(byte)(r>>24),0xC3],
|
||||
s.BuildCallStub((IntPtr)(nint)a,(IntPtr)(nint)t,[0x11111111,0x22222222,0x33333333,0x44444444],8,CallingConvention.Cdecl));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void X64_5args_push_cleanup()
|
||||
{
|
||||
var s=Create(); ulong a=0x100000000,t=0x123456788;
|
||||
uint ca=(uint)a+5+5+6+6+5,r=(uint)(t-(ca+5));
|
||||
Assert.Equal([
|
||||
0xB9,1,0,0,0, 0xBA,2,0,0,0,
|
||||
0x41,0xB8,3,0,0,0, 0x41,0xB9,4,0,0,0,
|
||||
0x68,5,0,0,0,
|
||||
0xE8,(byte)r,(byte)(r>>8),(byte)(r>>16),(byte)(r>>24),
|
||||
0x48,0x83,0xC4,8, 0xC3],
|
||||
s.BuildCallStub((IntPtr)(nint)a,(IntPtr)(nint)t,[1,2,3,4,5],8,CallingConvention.Cdecl));
|
||||
}
|
||||
|
||||
// ── No-FASM assertion ───────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void No_fasm_reference_in_output()
|
||||
{
|
||||
var asm = typeof(StubAssembler).Assembly;
|
||||
var refs = asm.GetReferencedAssemblies();
|
||||
Assert.DoesNotContain(refs, r =>
|
||||
r.Name!.Contains("Fasm", StringComparison.OrdinalIgnoreCase) ||
|
||||
r.Name!.Contains("ManagedFasm", StringComparison.OrdinalIgnoreCase));
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user