private static unsafe void Main(string[] args) { Add(1, 2); int tempInt = 0; (*(&tempInt)) = 9; if (tempInt == 9) { PrintLine("Hello from C#!"); } TestClass tempObj = new TestDerivedClass(1337); tempObj.TestMethod("Hello"); tempObj.TestVirtualMethod("Hello"); tempObj.TestVirtualMethod2("Hello"); TwoByteStr str = new TwoByteStr() { first = 1, second = 2 }; TwoByteStr str2 = new TwoByteStr() { first = 3, second = 4 }; *(&str) = str2; str2 = *(&str); if (str2.second == 4) { PrintLine("value type int field test: Ok."); } staticInt = 5; if (staticInt == 5) { PrintLine("static int field test: Ok."); } if (threadStaticInt == 0) { PrintLine("thread static int initial value field test: Ok."); } threadStaticInt = 9; if (threadStaticInt == 9) { PrintLine("thread static int field test: Ok."); } StaticCtorTest(); var boxedInt = (object)tempInt; if (((int)boxedInt) == 9) { PrintLine("box test: Ok."); } var boxedStruct = (object)new BoxStubTest { Value = "Boxed Stub Test: Ok." }; PrintLine(boxedStruct.ToString()); int subResult = tempInt - 1; if (subResult == 8) { PrintLine("Subtraction Test: Ok."); } int divResult = tempInt / 3; if (divResult == 3) { PrintLine("Division Test: Ok."); } var not = Not(0xFFFFFFFF) == 0x00000000; if (not) { PrintLine("not test: Ok."); } var negInt = Neg(42) == -42; if (negInt) { PrintLine("negInt test: Ok."); } var shiftLeft = ShiftLeft(1, 2) == 4; if (shiftLeft) { PrintLine("shiftLeft test: Ok."); } var shiftRight = ShiftRight(4, 2) == 1; if (shiftRight) { PrintLine("shiftRight test: Ok."); } var unsignedShift = UnsignedShift(0xFFFFFFFFu, 4) == 0x0FFFFFFFu; if (unsignedShift) { PrintLine("unsignedShift test: Ok."); } var switchTest0 = SwitchOp(5, 5, 0); if (switchTest0 == 10) { PrintLine("SwitchOp0 test: Ok."); } var switchTest1 = SwitchOp(5, 5, 1); if (switchTest1 == 25) { PrintLine("SwitchOp1 test: Ok."); } var switchTestDefault = SwitchOp(5, 5, 20); if (switchTestDefault == 0) { PrintLine("SwitchOpDefault test: Ok."); } #if PLATFORM_WINDOWS var cpObjTestA = new TestValue { Field = 1234 }; var cpObjTestB = new TestValue { Field = 5678 }; CpObjTest.CpObj(ref cpObjTestB, ref cpObjTestA); if (cpObjTestB.Field == 1234) { PrintLine("CpObj test: Ok."); } #endif Func <int> staticDelegate = StaticDelegateTarget; if (staticDelegate() == 7) { PrintLine("Static delegate test: Ok."); } tempObj.TestInt = 8; Func <int> instanceDelegate = tempObj.InstanceDelegateTarget; if (instanceDelegate() == 8) { PrintLine("Instance delegate test: Ok."); } Action virtualDelegate = tempObj.VirtualDelegateTarget; virtualDelegate(); var arrayTest = new BoxStubTest[] { new BoxStubTest { Value = "Hello" }, new BoxStubTest { Value = "Array" }, new BoxStubTest { Value = "Test" } }; foreach (var element in arrayTest) { PrintLine(element.Value); } arrayTest[1].Value = "Array load/store test: Ok."; PrintLine(arrayTest[1].Value); var largeArrayTest = new long[] { Int64.MaxValue, 0, Int64.MinValue, 0 }; if (largeArrayTest[0] == Int64.MaxValue && largeArrayTest[1] == 0 && largeArrayTest[2] == Int64.MinValue && largeArrayTest[3] == 0) { PrintLine("Large array load/store test: Ok."); } var smallArrayTest = new long[] { Int16.MaxValue, 0, Int16.MinValue, 0 }; if (smallArrayTest[0] == Int16.MaxValue && smallArrayTest[1] == 0 && smallArrayTest[2] == Int16.MinValue && smallArrayTest[3] == 0) { PrintLine("Small array load/store test: Ok."); } IntPtr returnedIntPtr = NewobjValueType(); if (returnedIntPtr.ToInt32() == 3) { PrintLine("Newobj value type test: Ok."); } StackallocTest(); IntToStringTest(); CastingTestClass castingTest = new DerivedCastingTestClass1(); if (((DerivedCastingTestClass1)castingTest).GetValue() == 1 && !(castingTest is DerivedCastingTestClass2)) { PrintLine("Type casting with isinst & castclass to class test: Ok."); } // Instead of checking the result of `GetValue`, we use null check by now until interface dispatch is implemented. if ((ICastingTest1)castingTest != null && !(castingTest is ICastingTest2)) { PrintLine("Type casting with isinst & castclass to interface test: Ok."); } object arrayCastingTest = new BoxStubTest[] { new BoxStubTest { Value = "Array" }, new BoxStubTest { Value = "Cast" }, new BoxStubTest { Value = "Test" } }; PrintLine(((BoxStubTest[])arrayCastingTest)[0].Value); PrintLine(((BoxStubTest[])arrayCastingTest)[1].Value); PrintLine(((BoxStubTest[])arrayCastingTest)[2].Value); if (!(arrayCastingTest is CastingTestClass[])) { PrintLine("Type casting with isinst & castclass to array test: Ok."); } ldindTest(); InterfaceDispatchTest(); var testRuntimeHelpersInitArray = new long[] { 1, 2, 3 }; if (testRuntimeHelpersInitArray[0] == 1 && testRuntimeHelpersInitArray[1] == 2 && testRuntimeHelpersInitArray[2] == 3) { PrintLine("Runtime.Helpers array initialization test: Ok."); } // This test should remain last to get other results before stopping the debugger PrintLine("Debugger.Break() test: Ok if debugger is open and breaks."); System.Diagnostics.Debugger.Break(); PrintLine("Done"); }
private static unsafe int Main(string[] args) { Success = true; PrintLine("Starting"); Add(1, 2); PrintLine("Hello from C#!"); int tempInt = 0; int tempInt2 = 0; StartTest("Address/derefernce test"); (*(&tempInt)) = 9; EndTest(tempInt == 9); int *targetAddr = (tempInt > 0) ? (&tempInt2) : (&tempInt); StartTest("basic block stack entry Test"); (*targetAddr) = 1; EndTest(tempInt2 == 1 && tempInt == 9); StartTest("Inline assign byte Test"); EndTest(ILHelpers.ILHelpersTest.InlineAssignByte() == 100); StartTest("dup test"); int dupTestInt = 9; EndTest(ILHelpers.ILHelpersTest.DupTest(ref dupTestInt) == 209 && dupTestInt == 209); TestClass tempObj = new TestDerivedClass(1337); tempObj.TestMethod("Hello"); tempObj.TestVirtualMethod("Hello"); tempObj.TestVirtualMethod2("Hello"); TwoByteStr str = new TwoByteStr() { first = 1, second = 2 }; TwoByteStr str2 = new TwoByteStr() { first = 3, second = 4 }; *(&str) = str2; str2 = *(&str); StartTest("value type int field test"); EndTest(str2.second == 4); StartTest("static int field test"); staticInt = 5; EndTest(staticInt == 5); StartTest("thread static int initial value field test"); EndTest(threadStaticInt == 0); StartTest("thread static int field test"); threadStaticInt = 9; EndTest(threadStaticInt == 9); StaticCtorTest(); StartTest("box test"); var boxedInt = (object)tempInt; if (((int)boxedInt) == 9) { PassTest(); } else { FailTest(); PrintLine("Value:"); PrintLine(boxedInt.ToString()); } var boxedStruct = (object)new BoxStubTest { Value = "Boxed Stub Test: Ok." }; PrintLine(boxedStruct.ToString()); StartTest("Subtraction Test"); int subResult = tempInt - 1; EndTest(subResult == 8); StartTest("Division Test"); int divResult = tempInt / 3; EndTest(divResult == 3); StartTest("not test"); var not = Not(0xFFFFFFFF) == 0x00000000; EndTest(not); StartTest("negInt test"); var negInt = Neg(42) == -42; EndTest(negInt); StartTest("shiftLeft test"); var shiftLeft = ShiftLeft(1, 2) == 4; EndTest(shiftLeft); StartTest("shiftRight test"); var shiftRight = ShiftRight(4, 2) == 1; EndTest(shiftRight); StartTest("unsignedShift test"); var unsignedShift = UnsignedShift(0xFFFFFFFFu, 4) == 0x0FFFFFFFu; EndTest(unsignedShift); StartTest("SwitchOp0 test"); var switchTest0 = SwitchOp(5, 5, 0); EndTest(switchTest0 == 10); StartTest("SwitchOp1 test"); var switchTest1 = SwitchOp(5, 5, 1); EndTest(switchTest1 == 25); StartTest("SwitchOpDefault test"); var switchTestDefault = SwitchOp(5, 5, 20); EndTest(switchTestDefault == 0); #if PLATFORM_WINDOWS StartTest("CpObj test"); var cpObjTestA = new TestValue { Field = 1234 }; var cpObjTestB = new TestValue { Field = 5678 }; CpObjTest.CpObj(ref cpObjTestB, ref cpObjTestA); EndTest(cpObjTestB.Field == 1234); #endif StartTest("Static delegate test"); Func <int> staticDelegate = StaticDelegateTarget; EndTest(staticDelegate() == 7); StartTest("Instance delegate test"); tempObj.TestInt = 8; Func <int> instanceDelegate = tempObj.InstanceDelegateTarget; EndTest(instanceDelegate() == 8); StartTest("Virtual Delegate Test"); Action virtualDelegate = tempObj.VirtualDelegateTarget; virtualDelegate(); var arrayTest = new BoxStubTest[] { new BoxStubTest { Value = "Hello" }, new BoxStubTest { Value = "Array" }, new BoxStubTest { Value = "Test" } }; foreach (var element in arrayTest) { PrintLine(element.Value); } arrayTest[1].Value = "Array load/store test: Ok."; PrintLine(arrayTest[1].Value); int ii = 0; arrayTest[ii++].Value = "dup ref test: Ok."; PrintLine(arrayTest[0].Value); StartTest("Large array load/store test"); var largeArrayTest = new long[] { Int64.MaxValue, 0, Int64.MinValue, 0 }; EndTest(largeArrayTest[0] == Int64.MaxValue && largeArrayTest[1] == 0 && largeArrayTest[2] == Int64.MinValue && largeArrayTest[3] == 0); StartTest("Small array load/store test"); var smallArrayTest = new long[] { Int16.MaxValue, 0, Int16.MinValue, 0 }; EndTest(smallArrayTest[0] == Int16.MaxValue && smallArrayTest[1] == 0 && smallArrayTest[2] == Int16.MinValue && smallArrayTest[3] == 0); StartTest("Newobj value type test"); IntPtr returnedIntPtr = NewobjValueType(); EndTest(returnedIntPtr.ToInt32() == 3); StackallocTest(); IntToStringTest(); CastingTestClass castingTest = new DerivedCastingTestClass1(); PrintLine("interface call test: Ok " + (castingTest as ICastingTest1).GetValue().ToString()); StartTest("Type casting with isinst & castclass to class test"); EndTest(((DerivedCastingTestClass1)castingTest).GetValue() == 1 && !(castingTest is DerivedCastingTestClass2)); StartTest("Type casting with isinst & castclass to interface test"); // Instead of checking the result of `GetValue`, we use null check by now until interface dispatch is implemented. EndTest((ICastingTest1)castingTest != null && !(castingTest is ICastingTest2)); StartTest("Type casting with isinst & castclass to array test"); object arrayCastingTest = new BoxStubTest[] { new BoxStubTest { Value = "Array" }, new BoxStubTest { Value = "Cast" }, new BoxStubTest { Value = "Test" } }; PrintLine(((BoxStubTest[])arrayCastingTest)[0].Value); PrintLine(((BoxStubTest[])arrayCastingTest)[1].Value); PrintLine(((BoxStubTest[])arrayCastingTest)[2].Value); EndTest(!(arrayCastingTest is CastingTestClass[])); ldindTest(); InterfaceDispatchTest(); StartTest("Runtime.Helpers array initialization test"); var testRuntimeHelpersInitArray = new long[] { 1, 2, 3 }; EndTest(testRuntimeHelpersInitArray[0] == 1 && testRuntimeHelpersInitArray[1] == 2 && testRuntimeHelpersInitArray[2] == 3); StartTest("Multi-dimension array instantiation test"); var testMdArrayInstantiation = new int[2, 2]; EndTest(testMdArrayInstantiation != null && testMdArrayInstantiation.GetLength(0) == 2 && testMdArrayInstantiation.GetLength(1) == 2); StartTest("Multi-dimension array get/set test"); testMdArrayInstantiation[0, 0] = 1; testMdArrayInstantiation[0, 1] = 2; testMdArrayInstantiation[1, 0] = 3; testMdArrayInstantiation[1, 1] = 4; EndTest(testMdArrayInstantiation[0, 0] == 1 && testMdArrayInstantiation[0, 1] == 2 && testMdArrayInstantiation[1, 0] == 3 && testMdArrayInstantiation[1, 1] == 4); FloatDoubleTest(); StartTest("long comparison"); long l = 0x1; EndTest(l < 0x7FF0000000000000); // Create a ByReference<char> through the ReadOnlySpan ctor and call the ByReference.Value via the indexer. StartTest("ByReference intrinsics exercise via ReadOnlySpan"); var span = "123".AsSpan(); if (span[0] != '1' || span[1] != '2' || span[2] != '3') { FailTest(); PrintLine(span[0].ToString()); PrintLine(span[1].ToString()); PrintLine(span[2].ToString()); } else { PassTest(); } TestConstrainedClassCalls(); TestValueTypeElementIndexing(); TestArrayItfDispatch(); TestMetaData(); TestTryFinally(); StartTest("RVA static field test"); int rvaFieldValue = ILHelpers.ILHelpersTest.StaticInitedInt; if (rvaFieldValue == 0x78563412) { PassTest(); } else { FailTest(rvaFieldValue.ToString()); } TestNativeCallback(); TestArgsWithMixedTypesAndExceptionRegions(); TestThreadStaticsForSingleThread(); TestDispose(); // This test should remain last to get other results before stopping the debugger PrintLine("Debugger.Break() test: Ok if debugger is open and breaks."); System.Diagnostics.Debugger.Break(); PrintLine("Done"); return(Success ? 100 : -1); }
private static unsafe void Main(string[] args) { Add(1, 2); int tempInt = 0; (*(&tempInt)) = 9; if (tempInt == 9) { PrintLine("Hello from C#!"); } TestClass tempObj = new TestDerivedClass(1337); tempObj.TestMethod("Hello"); tempObj.TestVirtualMethod("Hello"); tempObj.TestVirtualMethod2("Hello"); TwoByteStr str = new TwoByteStr() { first = 1, second = 2 }; TwoByteStr str2 = new TwoByteStr() { first = 3, second = 4 }; *(&str) = str2; str2 = *(&str); if (str2.second == 4) { PrintLine("value type int field test: Ok."); } staticInt = 5; if (staticInt == 5) { PrintLine("static int field test: Ok."); } var boxedInt = (object)tempInt; if (((int)boxedInt) == 9) { PrintLine("box test: Ok."); } var not = Not(0xFFFFFFFF) == 0x00000000; if (not) { PrintLine("not test: Ok."); } var negInt = Neg(42) == -42; if (negInt) { PrintLine("negInt test: Ok."); } var shiftLeft = ShiftLeft(1, 2) == 4; if (shiftLeft) { PrintLine("shiftLeft test: Ok."); } var shiftRight = ShiftRight(4, 2) == 1; if (shiftRight) { PrintLine("shiftRight test: Ok."); } var unsignedShift = UnsignedShift(0xFFFFFFFFu, 4) == 0x0FFFFFFFu; if (unsignedShift) { PrintLine("unsignedShift test: Ok."); } var switchTest0 = SwitchOp(5, 5, 0); if (switchTest0 == 10) { PrintLine("SwitchOp0 test: Ok."); } var switchTest1 = SwitchOp(5, 5, 1); if (switchTest1 == 25) { PrintLine("SwitchOp1 test: Ok."); } var switchTestDefault = SwitchOp(5, 5, 20); if (switchTestDefault == 0) { PrintLine("SwitchOpDefault test: Ok."); } }
private static unsafe int Main(string[] args) { Add(1, 2); int tempInt = 0; int tempInt2 = 0; (*(&tempInt)) = 9; if (tempInt == 9) { PrintLine("Hello from C#!"); } int *targetAddr = (tempInt > 0) ? (&tempInt2) : (&tempInt); (*targetAddr) = 1; if (tempInt2 == 1 && tempInt == 9) { PrintLine("basic block stack entry Test: Ok."); } if (ILHelpers.ILHelpersTest.InlineAssignByte() == 100) { PrintLine("Inline assign byte Test: Ok."); } if (ILHelpers.ILHelpersTest.DupTest(ref tempInt) == 209 && tempInt == 209) { PrintLine("dup test: Ok."); } TestClass tempObj = new TestDerivedClass(1337); tempObj.TestMethod("Hello"); tempObj.TestVirtualMethod("Hello"); tempObj.TestVirtualMethod2("Hello"); TwoByteStr str = new TwoByteStr() { first = 1, second = 2 }; TwoByteStr str2 = new TwoByteStr() { first = 3, second = 4 }; *(&str) = str2; str2 = *(&str); if (str2.second == 4) { PrintLine("value type int field test: Ok."); } staticInt = 5; if (staticInt == 5) { PrintLine("static int field test: Ok."); } if (threadStaticInt == 0) { PrintLine("thread static int initial value field test: Ok."); } threadStaticInt = 9; if (threadStaticInt == 9) { PrintLine("thread static int field test: Ok."); } StaticCtorTest(); var boxedInt = (object)tempInt; if (((int)boxedInt) == 9) { PrintLine("box test: Ok."); } var boxedStruct = (object)new BoxStubTest { Value = "Boxed Stub Test: Ok." }; PrintLine(boxedStruct.ToString()); int subResult = tempInt - 1; if (subResult == 8) { PrintLine("Subtraction Test: Ok."); } int divResult = tempInt / 3; if (divResult == 3) { PrintLine("Division Test: Ok."); } var not = Not(0xFFFFFFFF) == 0x00000000; if (not) { PrintLine("not test: Ok."); } var negInt = Neg(42) == -42; if (negInt) { PrintLine("negInt test: Ok."); } var shiftLeft = ShiftLeft(1, 2) == 4; if (shiftLeft) { PrintLine("shiftLeft test: Ok."); } var shiftRight = ShiftRight(4, 2) == 1; if (shiftRight) { PrintLine("shiftRight test: Ok."); } var unsignedShift = UnsignedShift(0xFFFFFFFFu, 4) == 0x0FFFFFFFu; if (unsignedShift) { PrintLine("unsignedShift test: Ok."); } var switchTest0 = SwitchOp(5, 5, 0); if (switchTest0 == 10) { PrintLine("SwitchOp0 test: Ok."); } var switchTest1 = SwitchOp(5, 5, 1); if (switchTest1 == 25) { PrintLine("SwitchOp1 test: Ok."); } var switchTestDefault = SwitchOp(5, 5, 20); if (switchTestDefault == 0) { PrintLine("SwitchOpDefault test: Ok."); } #if PLATFORM_WINDOWS var cpObjTestA = new TestValue { Field = 1234 }; var cpObjTestB = new TestValue { Field = 5678 }; CpObjTest.CpObj(ref cpObjTestB, ref cpObjTestA); if (cpObjTestB.Field == 1234) { PrintLine("CpObj test: Ok."); } #endif Func <int> staticDelegate = StaticDelegateTarget; if (staticDelegate() == 7) { PrintLine("Static delegate test: Ok."); } tempObj.TestInt = 8; Func <int> instanceDelegate = tempObj.InstanceDelegateTarget; if (instanceDelegate() == 8) { PrintLine("Instance delegate test: Ok."); } Action virtualDelegate = tempObj.VirtualDelegateTarget; virtualDelegate(); var arrayTest = new BoxStubTest[] { new BoxStubTest { Value = "Hello" }, new BoxStubTest { Value = "Array" }, new BoxStubTest { Value = "Test" } }; foreach (var element in arrayTest) { PrintLine(element.Value); } arrayTest[1].Value = "Array load/store test: Ok."; PrintLine(arrayTest[1].Value); int ii = 0; arrayTest[ii++].Value = "dup ref test: Ok."; PrintLine(arrayTest[0].Value); var largeArrayTest = new long[] { Int64.MaxValue, 0, Int64.MinValue, 0 }; if (largeArrayTest[0] == Int64.MaxValue && largeArrayTest[1] == 0 && largeArrayTest[2] == Int64.MinValue && largeArrayTest[3] == 0) { PrintLine("Large array load/store test: Ok."); } var smallArrayTest = new long[] { Int16.MaxValue, 0, Int16.MinValue, 0 }; if (smallArrayTest[0] == Int16.MaxValue && smallArrayTest[1] == 0 && smallArrayTest[2] == Int16.MinValue && smallArrayTest[3] == 0) { PrintLine("Small array load/store test: Ok."); } IntPtr returnedIntPtr = NewobjValueType(); if (returnedIntPtr.ToInt32() == 3) { PrintLine("Newobj value type test: Ok."); } StackallocTest(); IntToStringTest(); CastingTestClass castingTest = new DerivedCastingTestClass1(); PrintLine("interface call test: Ok " + (castingTest as ICastingTest1).GetValue().ToString()); if (((DerivedCastingTestClass1)castingTest).GetValue() == 1 && !(castingTest is DerivedCastingTestClass2)) { PrintLine("Type casting with isinst & castclass to class test: Ok."); } // Instead of checking the result of `GetValue`, we use null check by now until interface dispatch is implemented. if ((ICastingTest1)castingTest != null && !(castingTest is ICastingTest2)) { PrintLine("Type casting with isinst & castclass to interface test: Ok."); } object arrayCastingTest = new BoxStubTest[] { new BoxStubTest { Value = "Array" }, new BoxStubTest { Value = "Cast" }, new BoxStubTest { Value = "Test" } }; PrintLine(((BoxStubTest[])arrayCastingTest)[0].Value); PrintLine(((BoxStubTest[])arrayCastingTest)[1].Value); PrintLine(((BoxStubTest[])arrayCastingTest)[2].Value); if (!(arrayCastingTest is CastingTestClass[])) { PrintLine("Type casting with isinst & castclass to array test: Ok."); } ldindTest(); InterfaceDispatchTest(); var testRuntimeHelpersInitArray = new long[] { 1, 2, 3 }; if (testRuntimeHelpersInitArray[0] == 1 && testRuntimeHelpersInitArray[1] == 2 && testRuntimeHelpersInitArray[2] == 3) { PrintLine("Runtime.Helpers array initialization test: Ok."); } int intToCast = 1; double castedDouble = (double)intToCast; if (castedDouble == 1d) { PrintLine("(double) cast test: Ok."); } else { var toInt = (int)castedDouble; // PrintLine("expected 1m, but was " + castedDouble.ToString()); // double.ToString is not compiling at the time of writing, but this would be better output PrintLine($"(double) cast test : Failed. Back to int on next line"); PrintLine(toInt.ToString()); } if (1f < 2d && 1d < 2f && 1f == 1d) { PrintLine("different width float comparisons: Ok."); } // floats are 7 digits precision, so check some double more precise to make sure there is no loss occurring through some inadvertent cast to float if (10.23456789d != 10.234567891d) { PrintLine("double precision comparison: Ok."); } if (12.34567f == 12.34567f && 12.34567f != 12.34568f) { PrintLine("float comparison: Ok."); } // This test should remain last to get other results before stopping the debugger PrintLine("Debugger.Break() test: Ok if debugger is open and breaks."); System.Diagnostics.Debugger.Break(); PrintLine("Done"); return(100); }
private static unsafe void Main(string[] args) { Add(1, 2); int tempInt = 0; (*(&tempInt)) = 9; if (tempInt == 9) { PrintLine("Hello from C#!"); } TestClass tempObj = new TestDerivedClass(1337); tempObj.TestMethod("Hello"); tempObj.TestVirtualMethod("Hello"); tempObj.TestVirtualMethod2("Hello"); TwoByteStr str = new TwoByteStr() { first = 1, second = 2 }; TwoByteStr str2 = new TwoByteStr() { first = 3, second = 4 }; *(&str) = str2; str2 = *(&str); if (str2.second == 4) { PrintLine("value type int field test: Ok."); } staticInt = 5; if (staticInt == 5) { PrintLine("static int field test: Ok."); } if (threadStaticInt == 0) { PrintLine("thread static int initial value field test: Ok."); } threadStaticInt = 9; if (threadStaticInt == 9) { PrintLine("thread static int field test: Ok."); } var boxedInt = (object)tempInt; if (((int)boxedInt) == 9) { PrintLine("box test: Ok."); } var boxedStruct = (object)new BoxStubTest { Value = "Boxed Stub Test: Ok." }; PrintLine(boxedStruct.ToString()); var not = Not(0xFFFFFFFF) == 0x00000000; if (not) { PrintLine("not test: Ok."); } var negInt = Neg(42) == -42; if (negInt) { PrintLine("negInt test: Ok."); } var shiftLeft = ShiftLeft(1, 2) == 4; if (shiftLeft) { PrintLine("shiftLeft test: Ok."); } var shiftRight = ShiftRight(4, 2) == 1; if (shiftRight) { PrintLine("shiftRight test: Ok."); } var unsignedShift = UnsignedShift(0xFFFFFFFFu, 4) == 0x0FFFFFFFu; if (unsignedShift) { PrintLine("unsignedShift test: Ok."); } var switchTest0 = SwitchOp(5, 5, 0); if (switchTest0 == 10) { PrintLine("SwitchOp0 test: Ok."); } var switchTest1 = SwitchOp(5, 5, 1); if (switchTest1 == 25) { PrintLine("SwitchOp1 test: Ok."); } var switchTestDefault = SwitchOp(5, 5, 20); if (switchTestDefault == 0) { PrintLine("SwitchOpDefault test: Ok."); } var cpObjTestA = new TestValue { Field = 1234 }; var cpObjTestB = new TestValue { Field = 5678 }; CpObjTest.CpObj(ref cpObjTestB, ref cpObjTestA); if (cpObjTestB.Field == 1234) { PrintLine("CpObj test: Ok."); } }
private static unsafe void Main(string[] args) { Add(1, 2); int tempInt = 0; (*(&tempInt)) = 9; if (tempInt == 9) { PrintLine("Hello from C#!"); } TestClass tempObj = new TestDerivedClass(1337); tempObj.TestMethod("Hello"); tempObj.TestVirtualMethod("Hello"); tempObj.TestVirtualMethod2("Hello"); TwoByteStr str = new TwoByteStr() { first = 1, second = 2 }; TwoByteStr str2 = new TwoByteStr() { first = 3, second = 4 }; *(&str) = str2; str2 = *(&str); if (str2.second == 4) { PrintLine("value type int field test: Ok."); } staticInt = 5; if (staticInt == 5) { PrintLine("static int field test: Ok."); } if (threadStaticInt == 0) { PrintLine("thread static int initial value field test: Ok."); } threadStaticInt = 9; if (threadStaticInt == 9) { PrintLine("thread static int field test: Ok."); } var boxedInt = (object)tempInt; if (((int)boxedInt) == 9) { PrintLine("box test: Ok."); } var boxedStruct = (object)new BoxStubTest { Value = "Boxed Stub Test: Ok." }; PrintLine(boxedStruct.ToString()); var not = Not(0xFFFFFFFF) == 0x00000000; if (not) { PrintLine("not test: Ok."); } var negInt = Neg(42) == -42; if (negInt) { PrintLine("negInt test: Ok."); } var shiftLeft = ShiftLeft(1, 2) == 4; if (shiftLeft) { PrintLine("shiftLeft test: Ok."); } var shiftRight = ShiftRight(4, 2) == 1; if (shiftRight) { PrintLine("shiftRight test: Ok."); } var unsignedShift = UnsignedShift(0xFFFFFFFFu, 4) == 0x0FFFFFFFu; if (unsignedShift) { PrintLine("unsignedShift test: Ok."); } var switchTest0 = SwitchOp(5, 5, 0); if (switchTest0 == 10) { PrintLine("SwitchOp0 test: Ok."); } var switchTest1 = SwitchOp(5, 5, 1); if (switchTest1 == 25) { PrintLine("SwitchOp1 test: Ok."); } var switchTestDefault = SwitchOp(5, 5, 20); if (switchTestDefault == 0) { PrintLine("SwitchOpDefault test: Ok."); } var cpObjTestA = new TestValue { Field = 1234 }; var cpObjTestB = new TestValue { Field = 5678 }; CpObjTest.CpObj(ref cpObjTestB, ref cpObjTestA); if (cpObjTestB.Field == 1234) { PrintLine("CpObj test: Ok."); } Func <int> staticDelegate = StaticDelegateTarget; if (staticDelegate() == 7) { PrintLine("Static delegate test: Ok."); } tempObj.TestInt = 8; Func <int> instanceDelegate = tempObj.InstanceDelegateTarget; if (instanceDelegate() == 8) { PrintLine("Instance delegate test: Ok."); } Action virtualDelegate = tempObj.VirtualDelegateTarget; virtualDelegate(); var arrayTest = new BoxStubTest[] { new BoxStubTest { Value = "Hello" }, new BoxStubTest { Value = "Array" }, new BoxStubTest { Value = "Test" } }; foreach (var element in arrayTest) { PrintLine(element.Value); } arrayTest[1].Value = "Array load/store test: Ok."; PrintLine(arrayTest[1].Value); var largeArrayTest = new long[] { Int64.MaxValue, 0, Int64.MinValue, 0 }; if (largeArrayTest[0] == Int64.MaxValue && largeArrayTest[1] == 0 && largeArrayTest[2] == Int64.MinValue && largeArrayTest[3] == 0) { PrintLine("Large array load/store test: Ok."); } var smallArrayTest = new long[] { Int16.MaxValue, 0, Int16.MinValue, 0 }; if (smallArrayTest[0] == Int16.MaxValue && smallArrayTest[1] == 0 && smallArrayTest[2] == Int16.MinValue && smallArrayTest[3] == 0) { PrintLine("Small array load/store test: Ok."); } PrintLine("Done"); }