示例#1
0
    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");
    }
示例#2
0
    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);
    }
示例#3
0
    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.");
        }
    }
示例#4
0
    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);
    }
示例#5
0
    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.");
        }
    }
示例#6
0
    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");
    }