public void Int64Store8_Compiled_Offset0()
{
var compiled = MemoryWriteTestBase <long> .CreateInstance(
new GetLocal(0),
new GetLocal(1),
new Int64Store8(),
new End()
);
Assert.IsNotNull(compiled);
using (compiled)
{
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
exports.Test(0, 128);
Assert.AreEqual(128, Marshal.ReadInt32(memory.Start));
Assert.AreEqual(0, Marshal.ReadInt32(memory.Start, 1));
exports.Test((int)Memory.PageSize - 8, 1);
Assert.AreEqual(1, Marshal.ReadInt64(memory.Start, (int)Memory.PageSize - 8));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize, 0));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(1u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue), 0));
}
}
public void Float32Load_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <float> .CreateInstance(
new GetLocal(),
new Float32Load
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
var exports = compiled.Exports;
Assert.IsNotNull(exports);
var memory = exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
Assert.AreEqual(0, exports.Test(0));
var invariantCulture = CultureInfo.InvariantCulture;
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual("6.207163E-36", exports.Test(0).ToString(invariantCulture));
Assert.AreEqual("2.501747E-35", exports.Test(1).ToString(invariantCulture));
Assert.AreEqual("1.008251E-34", exports.Test(2).ToString(invariantCulture));
Assert.AreEqual("4.063216E-34", exports.Test(3).ToString(invariantCulture));
Assert.AreEqual("0.03320982", exports.Test(4).ToString(invariantCulture));
Assert.AreEqual("-8.313687E+14", exports.Test(5).ToString(invariantCulture));
Assert.AreEqual("9.602914E-14", exports.Test(6).ToString(invariantCulture));
Assert.AreEqual("-1.912281E+17", exports.Test(7).ToString(invariantCulture));
Assert.AreEqual("2.021882E-38", exports.Test(8).ToString(invariantCulture));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 5));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 4));
Assert.AreEqual(Memory.PageSize - 3, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 3));
Assert.AreEqual(Memory.PageSize - 2, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(4u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Float64Load_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <double> .CreateInstance(
new GetLocal(),
new Float64Load
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var invariantCulture = CultureInfo.InvariantCulture;
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual("1.06703248910785E-14", exports.Test(0).ToString(invariantCulture));
Assert.AreEqual("-1.14389371511465E+117", exports.Test(1).ToString(invariantCulture));
Assert.AreEqual("4.12824598825351E-107", exports.Test(2).ToString(invariantCulture));
Assert.AreEqual("-9.39245758009613E+135", exports.Test(3).ToString(invariantCulture));
Assert.AreEqual("1.60424369241791E-304", exports.Test(4).ToString(invariantCulture));
Assert.AreEqual("1.19599597184682E-309", exports.Test(5).ToString(invariantCulture));
Assert.AreEqual("4.6718592650265E-312", exports.Test(6).ToString(invariantCulture));
Assert.AreEqual("1.82494502538554E-314", exports.Test(7).ToString(invariantCulture));
Assert.AreEqual("7.12869138768568E-317", exports.Test(8).ToString(invariantCulture));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 9));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 8));
Assert.AreEqual(Memory.PageSize - 7, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 6));
Assert.AreEqual(Memory.PageSize - 5, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(8u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Int32Load_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <int> .CreateInstance(
new GetLocal(),
new Int32Load
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual(84148994, exports.Test(0));
Assert.AreEqual(100992003, exports.Test(1));
Assert.AreEqual(117835012, exports.Test(2));
Assert.AreEqual(134678021, exports.Test(3));
Assert.AreEqual(1023936262, exports.Test(4));
Assert.AreEqual(-667088889, exports.Test(5));
Assert.AreEqual(702037256, exports.Test(6));
Assert.AreEqual(-601237443, exports.Test(7));
Assert.AreEqual(14428632, exports.Test(8));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 5));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 4));
Assert.AreEqual(Memory.PageSize - 3, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 3));
Assert.AreEqual(Memory.PageSize - 2, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(4u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Int64Load_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <long> .CreateInstance(
new GetLocal(),
new Int64Load
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual(4397772758562636546, exports.Test(0));
Assert.AreEqual(-2865124961678982141, exports.Test(1));
Assert.AreEqual(3015227055211414788, exports.Test(2));
Assert.AreEqual(-2582295154680986107, exports.Test(3));
Assert.AreEqual(61970503589955334, exports.Test(4));
Assert.AreEqual(242072279648263, exports.Test(5));
Assert.AreEqual(945594842376, exports.Test(6));
Assert.AreEqual(3693729853, exports.Test(7));
Assert.AreEqual(14428632, exports.Test(8));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 9));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 8));
Assert.AreEqual(Memory.PageSize - 7, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 6));
Assert.AreEqual(Memory.PageSize - 5, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(8u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void End_Compiled_IncorrectStack_Expect1Actual0()
{
var exception = ExceptionAssert.Expect <StackSizeIncorrectException>(() =>
AssemblyBuilder.CreateInstance <dynamic>("Test", ValueType.Int32,
new End()
).Test());
Assert.AreEqual(1, exception.Expected);
Assert.AreEqual(0, exception.Actual);
}
public void Drop_Compiled()
{
Assert.AreEqual <int>(1, AssemblyBuilder.CreateInstance <dynamic>("Test", ValueType.Int32, new Int32Constant(1), new Int32Constant(2), new Drop(), new End()).Test());
var stackTooSmall = ExceptionAssert.Expect <StackTooSmallException>(() => AssemblyBuilder.CreateInstance <dynamic>("Test", null, new Drop(), new End()).Test());
Assert.AreEqual(OpCode.Drop, stackTooSmall.OpCode);
Assert.AreEqual(1, stackTooSmall.Minimum);
Assert.AreEqual(0, stackTooSmall.Actual);
}
public void Float32Store_Compiled_Offset1()
{
var compiled = MemoryWriteTestBase <float> .CreateInstance(
new GetLocal(0),
new GetLocal(1),
new Float32Store()
{
Offset = 1
},
new End()
);
Assert.IsNotNull(compiled);
using (compiled)
{
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
exports.Test(0, (float)Math.PI);
Assert.AreEqual(1225775872, Marshal.ReadInt32(memory.Start));
Assert.AreEqual(1078530011, Marshal.ReadInt32(memory.Start, 1));
Assert.AreEqual(4213007, Marshal.ReadInt32(memory.Start, 2));
Assert.AreEqual(16457, Marshal.ReadInt32(memory.Start, 3));
Assert.AreEqual(64, Marshal.ReadInt32(memory.Start, 4));
exports.Test((int)Memory.PageSize - 4 - 1, 1);
Assert.AreEqual(1065353216, Marshal.ReadInt32(memory.Start, (int)Memory.PageSize - 4));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 4, 0));
Assert.AreEqual(Memory.PageSize - 3, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 3, 0));
Assert.AreEqual(Memory.PageSize - 2, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2, 0));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1, 0));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(4u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue), 0));
}
}
public void Int32Store_Compiled_Offset1()
{
var compiled = MemoryWriteTestBase <int> .CreateInstance(
new GetLocal(0),
new GetLocal(1),
new Int32Store()
{
Offset = 1
},
new End()
);
Assert.IsNotNull(compiled);
using (compiled)
{
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
exports.Test(0, unchecked ((int)2147483648));
Assert.AreEqual(0, Marshal.ReadInt32(memory.Start));
Assert.AreEqual(-2147483648, Marshal.ReadInt32(memory.Start, 1));
Assert.AreEqual(8388608, Marshal.ReadInt32(memory.Start, 2));
Assert.AreEqual(32768, Marshal.ReadInt32(memory.Start, 3));
Assert.AreEqual(128, Marshal.ReadInt32(memory.Start, 4));
exports.Test((int)Memory.PageSize - 4 - 1, 1);
Assert.AreEqual(1, Marshal.ReadInt32(memory.Start, (int)Memory.PageSize - 4));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 4, 0));
Assert.AreEqual(Memory.PageSize - 3, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 3, 0));
Assert.AreEqual(Memory.PageSize - 2, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2, 0));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(4u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1, 0));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(4u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue), 0));
}
}
public void End_Compiled_BlockInt32_WrongType()
{
var exception = ExceptionAssert.Expect <StackTypeInvalidException>(() =>
AssemblyBuilder.CreateInstance <dynamic>("Test", ValueType.Int32,
new Block(BlockType.Int32),
new Int64Constant(5),
new End(),
new Int32WrapInt64(),
new End()
).Test());
Assert.AreEqual(ValueType.Int32, exception.Expected);
Assert.AreEqual(ValueType.Int64, exception.Actual);
}
public void End_Compiled_BlockFloat64_WrongType()
{
var exception = ExceptionAssert.Expect <StackTypeInvalidException>(() =>
AssemblyBuilder.CreateInstance <dynamic>("Test", ValueType.Float64,
new Block(BlockType.Float64),
new Float32Constant(5),
new End(),
new Float64PromoteFloat32(),
new End()
).Test());
Assert.AreEqual(ValueType.Float64, exception.Expected);
Assert.AreEqual(ValueType.Float32, exception.Actual);
}
public void Int32Load16Unsigned_Compiled_Offset1()
{
var compiled = MemoryReadTestBase <int> .CreateInstance(
new GetLocal(),
new Int32Load16Unsigned
{
Offset = 1,
},
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual(770, exports.Test(0));
Assert.AreEqual(1027, exports.Test(1));
Assert.AreEqual(1284, exports.Test(2));
Assert.AreEqual(1541, exports.Test(3));
Assert.AreEqual(1798, exports.Test(4));
Assert.AreEqual(2055, exports.Test(5));
Assert.AreEqual(15624, exports.Test(6));
Assert.AreEqual(55357, exports.Test(7));
Assert.AreEqual(10712, exports.Test(8));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 3));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(2u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(2u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Int64TruncateUnsignedFloat64_Compiled()
{
var exports = ConversionTestBase <double, long> .CreateInstance(
new GetLocal(0),
new Int64TruncateUnsignedFloat64(),
new End());
foreach (var value in new[] { 0, 1.5, -1.5, 123445678901234.0 })
{
Assert.AreEqual((long)value, exports.Test(value));
}
const double exceptional = 1234456789012345678901234567890.0;
ExceptionAssert.Expect <System.OverflowException>(() => exports.Test(exceptional));
}
public void Int32TruncateUnsignedFloat32_Compiled()
{
var exports = ConversionTestBase <float, int> .CreateInstance(
new GetLocal(0),
new Int32TruncateUnsignedFloat32(),
new End());
foreach (var value in new[] { 0, 1.5f, -1.5f })
{
Assert.AreEqual((int)value, exports.Test(value));
}
const float exceptional = 123445678901234f;
ExceptionAssert.Expect <System.OverflowException>(() => exports.Test(exceptional));
}
public void Int64Load8Unsigned_Compiled_Offset0()
{
var compiled = MemoryReadTestBase <long> .CreateInstance(
new GetLocal(),
new Int64Load8Unsigned(),
new End()
);
using (compiled)
{
Assert.IsNotNull(compiled);
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
Assert.AreEqual(0, exports.Test(0));
var testData = Samples.Memory;
Marshal.Copy(testData, 0, memory.Start, testData.Length);
Assert.AreEqual(254, exports.Test(0));
Assert.AreEqual(2, exports.Test(1));
Assert.AreEqual(3, exports.Test(2));
Assert.AreEqual(4, exports.Test(3));
Assert.AreEqual(5, exports.Test(4));
Assert.AreEqual(6, exports.Test(5));
Assert.AreEqual(7, exports.Test(6));
Assert.AreEqual(8, exports.Test(7));
Assert.AreEqual(61, exports.Test(8));
Assert.AreEqual(0, exports.Test((int)Memory.PageSize - 4));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(1u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue)));
}
}
public void Float64Store_Compiled_Offset1()
{
var compiled = MemoryWriteTestBase <double> .CreateInstance(
new GetLocal(0),
new GetLocal(1),
new Float64Store()
{
Offset = 1
},
new End()
);
Assert.IsNotNull(compiled);
using (compiled)
{
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
exports.Test(0, Math.PI);
Assert.AreEqual(1143805952, Marshal.ReadInt32(memory.Start));
Assert.AreEqual(1413754136, Marshal.ReadInt32(memory.Start, 1));
Assert.AreEqual(-78363603, Marshal.ReadInt32(memory.Start, 2));
Assert.AreEqual(570119236, Marshal.ReadInt32(memory.Start, 3));
Assert.AreEqual(153221972, Marshal.ReadInt32(memory.Start, 4));
exports.Test((int)Memory.PageSize - 8 - 1, 1);
Assert.AreEqual(4607182418800017408, Marshal.ReadInt64(memory.Start, (int)Memory.PageSize - 8));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 8, 0));
Assert.AreEqual(Memory.PageSize - 7, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 7, 0));
Assert.AreEqual(Memory.PageSize - 6, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 6, 0));
Assert.AreEqual(Memory.PageSize - 5, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 5, 0));
Assert.AreEqual(Memory.PageSize - 4, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 4, 0));
Assert.AreEqual(Memory.PageSize - 3, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 3, 0));
Assert.AreEqual(Memory.PageSize - 2, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2, 0));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1, 0));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(8u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue), 0));
}
}
public void Unreachable_Compiled()
{
ExceptionAssert.Expect <UnreachableException>(() => AssemblyBuilder.CreateInstance <dynamic>("Test", null, new Unreachable(), new End()).Test());
}
public void Int64Store_Compiled_Offset1()
{
var compiled = MemoryWriteTestBase <long> .CreateInstance(
new GetLocal(0),
new GetLocal(1),
new Int64Store()
{
Offset = 1
},
new End()
);
Assert.IsNotNull(compiled);
using (compiled)
{
Assert.IsNotNull(compiled.Exports);
var memory = compiled.Exports.Memory;
Assert.AreNotEqual(IntPtr.Zero, memory.Start);
var exports = compiled.Exports;
exports.Test(0, -9223372036854775808);
Assert.AreEqual(0, Marshal.ReadInt64(memory.Start));
Assert.AreEqual(-9223372036854775808, Marshal.ReadInt64(memory.Start, 1));
Assert.AreEqual(36028797018963968, Marshal.ReadInt64(memory.Start, 2));
Assert.AreEqual(140737488355328, Marshal.ReadInt64(memory.Start, 3));
Assert.AreEqual(549755813888, Marshal.ReadInt64(memory.Start, 4));
exports.Test((int)Memory.PageSize - 8 - 1, 1);
Assert.AreEqual(1, Marshal.ReadInt64(memory.Start, (int)Memory.PageSize - 8));
MemoryAccessOutOfRangeException x;
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 8, 0));
Assert.AreEqual(Memory.PageSize - 7, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 7, 0));
Assert.AreEqual(Memory.PageSize - 6, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 6, 0));
Assert.AreEqual(Memory.PageSize - 5, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 5, 0));
Assert.AreEqual(Memory.PageSize - 4, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 4, 0));
Assert.AreEqual(Memory.PageSize - 3, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 3, 0));
Assert.AreEqual(Memory.PageSize - 2, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 2, 0));
Assert.AreEqual(Memory.PageSize - 1, x.Offset);
Assert.AreEqual(8u, x.Length);
x = ExceptionAssert.Expect <MemoryAccessOutOfRangeException>(() => exports.Test((int)Memory.PageSize - 1, 0));
Assert.AreEqual(Memory.PageSize, x.Offset);
Assert.AreEqual(8u, x.Length);
ExceptionAssert.Expect <OverflowException>(() => exports.Test(unchecked ((int)uint.MaxValue), 0));
}
}
