diff options
Diffstat (limited to 'tests/src/Regressions/coreclr/GitHub_7685/test7685.cs')
| -rw-r--r-- | tests/src/Regressions/coreclr/GitHub_7685/test7685.cs | 191 |
1 files changed, 183 insertions, 8 deletions
diff --git a/tests/src/Regressions/coreclr/GitHub_7685/test7685.cs b/tests/src/Regressions/coreclr/GitHub_7685/test7685.cs index a1d35bc11c..77b25dc59c 100644 --- a/tests/src/Regressions/coreclr/GitHub_7685/test7685.cs +++ b/tests/src/Regressions/coreclr/GitHub_7685/test7685.cs @@ -6,28 +6,100 @@ using System.Reflection; public class Test7685 { - static RectangleF argumentInDStuff; - + static RectangleF passedFloatStruct; + static RectangleD passedDoubleStruct; + static RectangleI passedIntStruct; + static RectangleLLarge passedLongLargeStruct; + static RectangleLSmall passedLongSmallStruct; + static RectangleNestedF passedNestedSmallFStruct; + public static int Main() { int iRetVal = 100; - var r = new RectangleF(1.2f, 3.4f, 5.6f, 7.8f); - typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuff").Invoke(null, new object[] { r }); + var rF = new RectangleF(1.2f, 3.4f, 5.6f, 7.8f); + var rD = new RectangleD(1.7E+3d, 4.5d, 500.1d, 60.0d); + var rI = new RectangleI(100, -2, 3, 64); + var rLSmall = new RectangleLSmall(11231L); + var rLLarge = new RectangleLLarge(1L, 20041L, 22L, 88L); + var rNestedFSmall = new RectangleNestedF(1.2f, 3.4f, 5.6f, 7.8f); + + typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffF").Invoke(null, new object[] { rF }); + typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffD").Invoke(null, new object[] { rD }); + typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffI").Invoke(null, new object[] { rI }); + typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffLSmall").Invoke(null, new object[] { rLSmall }); + typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffLLarge").Invoke(null, new object[] { rLLarge }); + typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffNestedF").Invoke(null, new object[] { rNestedFSmall }); - if (!RectangleF.Equals(ref argumentInDStuff, ref r)) + if (!RectangleF.Equals(ref passedFloatStruct, ref rF)) { - TestLibrary.Logging.WriteLine($"Error: passing struct with floats via reflection. Callee received {argumentInDStuff} instead of {r}"); + TestLibrary.Logging.WriteLine($"Error: passing struct with floats via reflection. Callee received {passedFloatStruct} instead of {rF}"); iRetVal = 0; } + + if (!RectangleD.Equals(ref passedDoubleStruct, ref rD)) + { + TestLibrary.Logging.WriteLine($"Error: passing struct with doubles via reflection. Callee received {passedDoubleStruct} instead of {rD}"); + iRetVal = 1; + } + + if (!RectangleI.Equals(ref passedIntStruct, ref rI)) + { + TestLibrary.Logging.WriteLine($"Error: passing struct with ints via reflection. Callee received {passedIntStruct} instead of {rI}"); + iRetVal = 2; + } + + if (!RectangleLSmall.Equals(ref passedLongSmallStruct, ref rLSmall)) + { + TestLibrary.Logging.WriteLine($"Error: passing struct with a long via reflection. Callee received {passedLongSmallStruct} instead of {rLSmall}"); + iRetVal = 3; + } + + if (!RectangleLLarge.Equals(ref passedLongLargeStruct, ref rLLarge)) + { + TestLibrary.Logging.WriteLine($"Error: passing struct with longs via reflection. Callee received {passedLongLargeStruct} instead of {rLLarge}"); + iRetVal = 4; + } + + if (!RectangleNestedF.Equals(ref passedNestedSmallFStruct, ref rNestedFSmall)) + { + TestLibrary.Logging.WriteLine($"Error: passing struct with longs via reflection. Callee received {passedNestedSmallFStruct} instead of {rNestedFSmall}"); + iRetVal = 5; + } return iRetVal; } - public static void DoStuff(RectangleF r) + public static void DoStuffF(RectangleF r) + { + passedFloatStruct = r; + } + + public static void DoStuffD(RectangleD r) + { + passedDoubleStruct = r; + } + + public static void DoStuffI(RectangleI r) + { + passedIntStruct = r; + } + + public static void DoStuffLSmall(RectangleLSmall r) { - argumentInDStuff = r; + passedLongSmallStruct = r; } + + public static void DoStuffLLarge(RectangleLLarge r) + { + passedLongLargeStruct = r; + } + + public static void DoStuffNestedF(RectangleNestedF r) + { + passedNestedSmallFStruct = r; + } + } public struct RectangleF @@ -46,3 +118,106 @@ public struct RectangleF public override string ToString() => $"[{_x}, {_y}, {_width}, {_height}]"; } + +public struct RectangleFSmall +{ + public float _x, _y; + + public RectangleFSmall(float x, float y) + { + _x = x; _y = y; + } + + public static bool Equals(ref RectangleFSmall r1, ref RectangleFSmall r2) + { + return (r2._x == r1._x) && (r2._y == r1._y); + } + + public override string ToString() => $"[{_x}, {_y}]"; +} + +public struct RectangleD +{ + private double _x, _y, _width, _height; + + public RectangleD(double x, double y, double width, double height) + { + _x = x; _y = y; _width = width; _height = height; + } + + public static bool Equals(ref RectangleD r1, ref RectangleD r2) + { + return (r2._x == r1._x) && (r2._y == r1._y) && (r2._width == r1._width) && (r2._height == r1._height); + } + + public override string ToString() => $"[{_x}, {_y}, {_width}, {_height}]"; +} + +public struct RectangleI +{ + private int _x, _y, _width, _height; + + public RectangleI(int x, int y, int width, int height) + { + _x = x; _y = y; _width = width; _height = height; + } + + public static bool Equals(ref RectangleI r1, ref RectangleI r2) + { + return (r2._x == r1._x) && (r2._y == r1._y) && (r2._width == r1._width) && (r2._height == r1._height); + } + + public override string ToString() => $"[{_x}, {_y}, {_width}, {_height}]"; +} + +public struct RectangleLSmall +{ + private long _x; + + public RectangleLSmall(long x) + { + _x = x; + } + + public static bool Equals(ref RectangleLSmall r1, ref RectangleLSmall r2) + { + return (r2._x == r1._x); + } + + public override string ToString() => $"[{_x}]"; +} + +public struct RectangleLLarge +{ + private long _x, _y, _width, _height; + + public RectangleLLarge(long x, long y, long width, long height) + { + _x = x; _y = y; _width = width; _height = height; + } + + public static bool Equals(ref RectangleLLarge r1, ref RectangleLLarge r2) + { + return (r2._x == r1._x) && (r2._y == r1._y) && (r2._width == r1._width) && (r2._height == r1._height); + } + + public override string ToString() => $"[{_x}, {_y}, {_width}, {_height}]"; +} + +public struct RectangleNestedF +{ + private RectangleFSmall first, second; + + public RectangleNestedF(float x, float y, float width, float height) + { + first = new RectangleFSmall(x, y); + second = new RectangleFSmall(width, height); + } + + public static bool Equals(ref RectangleNestedF r1, ref RectangleNestedF r2) + { + return (r1.first._x == r2.first._x) && (r1.first._y == r2.first._y) && (r1.second._x == r2.second._x) && (r1.second._y == r2.second._y); + } + + public override string ToString() => $"[{first._x}, {first._y}, {second._x}, {second._y}]"; +}
\ No newline at end of file |