From c9d4a03e67dcca0c7cd3e9d2cb6bd9ef51ee8669 Mon Sep 17 00:00:00 2001 From: Bengu Li Date: Fri, 8 May 2015 16:50:42 -0700 Subject: [PATCH] Add Methodical/NaN test cases for JIT. Add Methodical/NaN test cases for JIT. Related proj, config, and sln files added and updated. Passed build, buildtest, runtest. Also added Generic/Exceptions, Methodical/MDArray/DataTypes, Directed/StructPromote tests to AllTestProject.sln. --- tests/src/AllTestProjects.sln | 70 ++ tests/src/JIT/Methodical/NaN/NaN.csproj | 19 + tests/src/JIT/Methodical/NaN/app.config | 27 + tests/src/JIT/Methodical/NaN/arithm32.cs | 94 +++ tests/src/JIT/Methodical/NaN/arithm64.cs | 94 +++ tests/src/JIT/Methodical/NaN/cs_template.proj | 42 + tests/src/JIT/Methodical/NaN/packages.config | 6 + tests/src/JIT/Methodical/NaN/r4NaNadd.cs | 1103 ++++++++++++++++++++++++ tests/src/JIT/Methodical/NaN/r4NaNdiv.cs | 1107 ++++++++++++++++++++++++ tests/src/JIT/Methodical/NaN/r4NaNmul.cs | 1107 ++++++++++++++++++++++++ tests/src/JIT/Methodical/NaN/r4NaNrem.cs | 1107 ++++++++++++++++++++++++ tests/src/JIT/Methodical/NaN/r4NaNsub.cs | 1108 +++++++++++++++++++++++++ tests/src/JIT/Methodical/NaN/r8NaNadd.cs | 1106 ++++++++++++++++++++++++ tests/src/JIT/Methodical/NaN/r8NaNdiv.cs | 1108 +++++++++++++++++++++++++ tests/src/JIT/Methodical/NaN/r8NaNmul.cs | 1107 ++++++++++++++++++++++++ tests/src/JIT/Methodical/NaN/r8NaNrem.cs | 1107 ++++++++++++++++++++++++ tests/src/JIT/Methodical/NaN/r8NaNsub.cs | 1107 ++++++++++++++++++++++++ 17 files changed, 11419 insertions(+) create mode 100644 tests/src/JIT/Methodical/NaN/NaN.csproj create mode 100644 tests/src/JIT/Methodical/NaN/app.config create mode 100644 tests/src/JIT/Methodical/NaN/arithm32.cs create mode 100644 tests/src/JIT/Methodical/NaN/arithm64.cs create mode 100644 tests/src/JIT/Methodical/NaN/cs_template.proj create mode 100644 tests/src/JIT/Methodical/NaN/packages.config create mode 100644 tests/src/JIT/Methodical/NaN/r4NaNadd.cs create mode 100644 tests/src/JIT/Methodical/NaN/r4NaNdiv.cs create mode 100644 tests/src/JIT/Methodical/NaN/r4NaNmul.cs create mode 100644 tests/src/JIT/Methodical/NaN/r4NaNrem.cs create mode 100644 tests/src/JIT/Methodical/NaN/r4NaNsub.cs create mode 100644 tests/src/JIT/Methodical/NaN/r8NaNadd.cs create mode 100644 tests/src/JIT/Methodical/NaN/r8NaNdiv.cs create mode 100644 tests/src/JIT/Methodical/NaN/r8NaNmul.cs create mode 100644 tests/src/JIT/Methodical/NaN/r8NaNrem.cs create mode 100644 tests/src/JIT/Methodical/NaN/r8NaNsub.cs diff --git a/tests/src/AllTestProjects.sln b/tests/src/AllTestProjects.sln index 42cee68..1c3c02f 100644 --- a/tests/src/AllTestProjects.sln +++ b/tests/src/AllTestProjects.sln @@ -149,6 +149,26 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Fields", "Fields", "{469D4D EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Fields", "JIT\Generics\Fields\Fields.csproj", "{F40B2B5B-4C42-4BD8-8CAF-8C96856BAC0F}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "StructPromote", "StructPromote", "{A8B34174-E462-48BE-975C-604B8B1DB0A0}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StructPromote", "JIT\Directed\StructPromote\StructPromote.csproj", "{11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "MDArray", "MDArray", "{1E30345B-4538-426B-8F15-94C7EDD9F6A1}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "DataTypes", "DataTypes", "{48E311DE-F4D4-4F54-8C2B-FEDA15FE2D40}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Methodical", "Methodical", "{D83DE650-AD2D-4122-9AE2-53AB5364D032}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DataTypes", "JIT\Methodical\MDArray\DataTypes\DataTypes.csproj", "{1A50E251-BD04-4049-9745-770CFF672093}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Exceptions", "Exceptions", "{165B27F0-A2BA-4961-B718-0E381B8B92BD}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Exceptions", "JIT\Generics\Exceptions\Exceptions.csproj", "{E16B0693-80CF-422F-AB4B-B5150FDF5140}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "NaN", "NaN", "{06633516-0C78-433B-BFFB-A8BCE5006CB7}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NaN", "JIT\Methodical\NaN\NaN.csproj", "{5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -437,6 +457,46 @@ Global {F40B2B5B-4C42-4BD8-8CAF-8C96856BAC0F}.Release|Mixed Platforms.Build.0 = Release|x64 {F40B2B5B-4C42-4BD8-8CAF-8C96856BAC0F}.Release|x64.ActiveCfg = Release|x64 {F40B2B5B-4C42-4BD8-8CAF-8C96856BAC0F}.Release|x64.Build.0 = Release|x64 + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}.Debug|Any CPU.ActiveCfg = Debug|x64 + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}.Debug|Mixed Platforms.ActiveCfg = Debug|x64 + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}.Debug|Mixed Platforms.Build.0 = Debug|x64 + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}.Debug|x64.ActiveCfg = Debug|x64 + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}.Debug|x64.Build.0 = Debug|x64 + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}.Release|Any CPU.ActiveCfg = Release|x64 + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}.Release|Mixed Platforms.ActiveCfg = Release|x64 + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}.Release|Mixed Platforms.Build.0 = Release|x64 + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}.Release|x64.ActiveCfg = Release|x64 + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9}.Release|x64.Build.0 = Release|x64 + {1A50E251-BD04-4049-9745-770CFF672093}.Debug|Any CPU.ActiveCfg = Debug|x64 + {1A50E251-BD04-4049-9745-770CFF672093}.Debug|Mixed Platforms.ActiveCfg = Debug|x64 + {1A50E251-BD04-4049-9745-770CFF672093}.Debug|Mixed Platforms.Build.0 = Debug|x64 + {1A50E251-BD04-4049-9745-770CFF672093}.Debug|x64.ActiveCfg = Debug|x64 + {1A50E251-BD04-4049-9745-770CFF672093}.Debug|x64.Build.0 = Debug|x64 + {1A50E251-BD04-4049-9745-770CFF672093}.Release|Any CPU.ActiveCfg = Release|x64 + {1A50E251-BD04-4049-9745-770CFF672093}.Release|Mixed Platforms.ActiveCfg = Release|x64 + {1A50E251-BD04-4049-9745-770CFF672093}.Release|Mixed Platforms.Build.0 = Release|x64 + {1A50E251-BD04-4049-9745-770CFF672093}.Release|x64.ActiveCfg = Release|x64 + {1A50E251-BD04-4049-9745-770CFF672093}.Release|x64.Build.0 = Release|x64 + {E16B0693-80CF-422F-AB4B-B5150FDF5140}.Debug|Any CPU.ActiveCfg = Debug|x64 + {E16B0693-80CF-422F-AB4B-B5150FDF5140}.Debug|Mixed Platforms.ActiveCfg = Debug|x64 + {E16B0693-80CF-422F-AB4B-B5150FDF5140}.Debug|Mixed Platforms.Build.0 = Debug|x64 + {E16B0693-80CF-422F-AB4B-B5150FDF5140}.Debug|x64.ActiveCfg = Debug|x64 + {E16B0693-80CF-422F-AB4B-B5150FDF5140}.Debug|x64.Build.0 = Debug|x64 + {E16B0693-80CF-422F-AB4B-B5150FDF5140}.Release|Any CPU.ActiveCfg = Release|x64 + {E16B0693-80CF-422F-AB4B-B5150FDF5140}.Release|Mixed Platforms.ActiveCfg = Release|x64 + {E16B0693-80CF-422F-AB4B-B5150FDF5140}.Release|Mixed Platforms.Build.0 = Release|x64 + {E16B0693-80CF-422F-AB4B-B5150FDF5140}.Release|x64.ActiveCfg = Release|x64 + {E16B0693-80CF-422F-AB4B-B5150FDF5140}.Release|x64.Build.0 = Release|x64 + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}.Debug|Any CPU.ActiveCfg = Debug|x64 + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}.Debug|Mixed Platforms.ActiveCfg = Debug|x64 + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}.Debug|Mixed Platforms.Build.0 = Debug|x64 + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}.Debug|x64.ActiveCfg = Debug|x64 + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}.Debug|x64.Build.0 = Debug|x64 + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}.Release|Any CPU.ActiveCfg = Release|x64 + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}.Release|Mixed Platforms.ActiveCfg = Release|x64 + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}.Release|Mixed Platforms.Build.0 = Release|x64 + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}.Release|x64.ActiveCfg = Release|x64 + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF}.Release|x64.Build.0 = Release|x64 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -449,6 +509,7 @@ Global {D9FFDA0F-00A2-458C-B3D3-77D0811E969E} = {F03E5C26-F7BE-4BEF-9CBC-EAFC5A2C7760} {4528D9E6-C6F8-448E-BD36-5E5DAAFE90D3} = {F03E5C26-F7BE-4BEF-9CBC-EAFC5A2C7760} {0957EF12-6D74-4438-BAD1-D720433C2162} = {F03E5C26-F7BE-4BEF-9CBC-EAFC5A2C7760} + {D83DE650-AD2D-4122-9AE2-53AB5364D032} = {F03E5C26-F7BE-4BEF-9CBC-EAFC5A2C7760} {B6FB99A0-1E53-4806-AE96-3A157F8B4DFD} = {3E36F081-F511-4C52-BC3D-2EEFECD3E880} {01516861-E37C-433B-9D12-CA4F8E05CB13} = {3E36F081-F511-4C52-BC3D-2EEFECD3E880} {9CF3FD0C-3643-4F57-A57C-492258FF1BF0} = {C86BB69B-B83E-4656-825F-50CADB38D344} @@ -477,6 +538,7 @@ Global {168FB13B-74F9-4056-BF11-A46F2DAAADF8} = {86AB78FA-656D-47D1-B156-F8165542A6C1} {3AC4E363-B239-4D48-AEB8-A9177554E156} = {86AB78FA-656D-47D1-B156-F8165542A6C1} {BA784A0F-E788-40CC-A76D-EB4041808897} = {86AB78FA-656D-47D1-B156-F8165542A6C1} + {A8B34174-E462-48BE-975C-604B8B1DB0A0} = {86AB78FA-656D-47D1-B156-F8165542A6C1} {BA57FEA2-9416-4FE6-9767-7C63CE8EFBC7} = {168FB13B-74F9-4056-BF11-A46F2DAAADF8} {6B543CA2-10A2-4771-9F93-1733AA7A2DB8} = {1E0A9AAE-133F-4881-8DC6-571F12B96B8B} {39DD9A75-2535-4EBD-94A4-C7DF7EF12CF5} = {6B543CA2-10A2-4771-9F93-1733AA7A2DB8} @@ -493,6 +555,7 @@ Global {472DA1F4-C446-434B-906C-A0F2899C279B} = {BA784A0F-E788-40CC-A76D-EB4041808897} {C3F22F91-FE0E-4181-864B-D7EE7225382D} = {4528D9E6-C6F8-448E-BD36-5E5DAAFE90D3} {469D4D65-45B3-4641-9C04-480102731EF9} = {4528D9E6-C6F8-448E-BD36-5E5DAAFE90D3} + {165B27F0-A2BA-4961-B718-0E381B8B92BD} = {4528D9E6-C6F8-448E-BD36-5E5DAAFE90D3} {C5825007-742C-4F16-BAB5-09D6EAF2AEF6} = {C3F22F91-FE0E-4181-864B-D7EE7225382D} {1E8B3DDB-15DC-4BB9-BAFB-8252848A8784} = {C3F22F91-FE0E-4181-864B-D7EE7225382D} {A1C4D795-DE5B-4CB0-BFF6-13E1D5A787FD} = {C5825007-742C-4F16-BAB5-09D6EAF2AEF6} @@ -506,5 +569,12 @@ Global {8C754381-F489-4B5F-885A-415D323D88BF} = {0957EF12-6D74-4438-BAD1-D720433C2162} {757F1684-39BD-4705-91F1-FE16BD5B1523} = {8C754381-F489-4B5F-885A-415D323D88BF} {F40B2B5B-4C42-4BD8-8CAF-8C96856BAC0F} = {469D4D65-45B3-4641-9C04-480102731EF9} + {11835CDF-F5AA-42B9-9FE6-6F94EB9A08B9} = {A8B34174-E462-48BE-975C-604B8B1DB0A0} + {48E311DE-F4D4-4F54-8C2B-FEDA15FE2D40} = {1E30345B-4538-426B-8F15-94C7EDD9F6A1} + {1A50E251-BD04-4049-9745-770CFF672093} = {48E311DE-F4D4-4F54-8C2B-FEDA15FE2D40} + {1E30345B-4538-426B-8F15-94C7EDD9F6A1} = {D83DE650-AD2D-4122-9AE2-53AB5364D032} + {06633516-0C78-433B-BFFB-A8BCE5006CB7} = {D83DE650-AD2D-4122-9AE2-53AB5364D032} + {E16B0693-80CF-422F-AB4B-B5150FDF5140} = {165B27F0-A2BA-4961-B718-0E381B8B92BD} + {5FEB6365-EB6C-4D4D-9DAA-E5E2EEA5A1FF} = {06633516-0C78-433B-BFFB-A8BCE5006CB7} EndGlobalSection EndGlobal diff --git a/tests/src/JIT/Methodical/NaN/NaN.csproj b/tests/src/JIT/Methodical/NaN/NaN.csproj new file mode 100644 index 0000000..33b2928 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/NaN.csproj @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + false + + + + diff --git a/tests/src/JIT/Methodical/NaN/app.config b/tests/src/JIT/Methodical/NaN/app.config new file mode 100644 index 0000000..62803f5 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/app.config @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/tests/src/JIT/Methodical/NaN/arithm32.cs b/tests/src/JIT/Methodical/NaN/arithm32.cs new file mode 100644 index 0000000..ba1e177 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/arithm32.cs @@ -0,0 +1,94 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace JitTest +{ + using System; + + class Test + { + static void RunTests(float nan, float plusinf, float minusinf) + { + if (!Single.IsNaN(nan + nan)) + throw new Exception("! Single.IsNaN(nan + nan)"); + if (!Single.IsNaN(nan + plusinf)) + throw new Exception("! Single.IsNaN(nan + plusinf)"); + if (!Single.IsNaN(nan + minusinf)) + throw new Exception("! Single.IsNaN(nan + minusinf)"); + if (!Single.IsNaN(plusinf + nan)) + throw new Exception("! Single.IsNaN(plusinf + nan)"); + if (!Single.IsPositiveInfinity(plusinf + plusinf)) + throw new Exception("! Single.IsPositiveInfinity(plusinf + plusinf)"); + if (!Single.IsNaN(plusinf + minusinf)) + throw new Exception("! Single.IsNaN(plusinf + minusinf)"); + if (!Single.IsNaN(minusinf + nan)) + throw new Exception("! Single.IsNaN(minusinf + nan)"); + if (!Single.IsNaN(minusinf + plusinf)) + throw new Exception("! Single.IsNaN(minusinf + plusinf)"); + if (!Single.IsNegativeInfinity(minusinf + minusinf)) + throw new Exception("! Single.IsNegativeInfinity(minusinf + minusinf)"); + if (!Single.IsNaN(nan + nan)) + throw new Exception("! Single.IsNaN(nan + nan)"); + if (!Single.IsNaN(nan + plusinf)) + throw new Exception("! Single.IsNaN(nan + plusinf)"); + if (!Single.IsNaN(nan + minusinf)) + throw new Exception("! Single.IsNaN(nan + minusinf)"); + if (!Single.IsNaN(plusinf + nan)) + throw new Exception("! Single.IsNaN(plusinf + nan)"); + if (!Single.IsPositiveInfinity(plusinf + plusinf)) + throw new Exception("! Single.IsPositiveInfinity(plusinf + plusinf)"); + if (!Single.IsNaN(plusinf + minusinf)) + throw new Exception("! Single.IsNaN(plusinf + minusinf)"); + if (!Single.IsNaN(minusinf + nan)) + throw new Exception("! Single.IsNaN(minusinf + nan)"); + if (!Single.IsNaN(minusinf + plusinf)) + throw new Exception("! Single.IsNaN(minusinf + plusinf)"); + if (!Single.IsNegativeInfinity(minusinf + minusinf)) + throw new Exception("! Single.IsNegativeInfinity(minusinf + minusinf)"); + if (!Single.IsNaN(nan + nan)) + throw new Exception("! Single.IsNaN(nan + nan)"); + if (!Single.IsNaN(nan + plusinf)) + throw new Exception("! Single.IsNaN(nan + plusinf)"); + if (!Single.IsNaN(nan + minusinf)) + throw new Exception("! Single.IsNaN(nan + minusinf)"); + if (!Single.IsNaN(plusinf + nan)) + throw new Exception("! Single.IsNaN(plusinf + nan)"); + if (!Single.IsPositiveInfinity(plusinf + plusinf)) + throw new Exception("! Single.IsPositiveInfinity(plusinf + plusinf)"); + if (!Single.IsNaN(plusinf + minusinf)) + throw new Exception("! Single.IsNaN(plusinf + minusinf)"); + if (!Single.IsNaN(minusinf + nan)) + throw new Exception("! Single.IsNaN(minusinf + nan)"); + if (!Single.IsNaN(minusinf + plusinf)) + throw new Exception("! Single.IsNaN(minusinf + plusinf)"); + if (!Single.IsNegativeInfinity(minusinf + minusinf)) + throw new Exception("! Single.IsNegativeInfinity(minusinf + minusinf)"); + if (!Single.IsNaN(nan + nan)) + throw new Exception("! Single.IsNaN(nan + nan)"); + if (!Single.IsNaN(nan + plusinf)) + throw new Exception("! Single.IsNaN(nan + plusinf)"); + if (!Single.IsNaN(nan + minusinf)) + throw new Exception("! Single.IsNaN(nan + minusinf)"); + if (!Single.IsNaN(plusinf + nan)) + throw new Exception("! Single.IsNaN(plusinf + nan)"); + if (!Single.IsPositiveInfinity(plusinf + plusinf)) + throw new Exception("! Single.IsPositiveInfinity(plusinf + plusinf)"); + if (!Single.IsNaN(plusinf + minusinf)) + throw new Exception("! Single.IsNaN(plusinf + minusinf)"); + if (!Single.IsNaN(minusinf + nan)) + throw new Exception("! Single.IsNaN(minusinf + nan)"); + if (!Single.IsNaN(minusinf + plusinf)) + throw new Exception("! Single.IsNaN(minusinf + plusinf)"); + if (!Single.IsNegativeInfinity(minusinf + minusinf)) + throw new Exception("! Single.IsNegativeInfinity(minusinf + minusinf)"); + } + + static int Main() + { + RunTests(Single.NaN, Single.PositiveInfinity, Single.NegativeInfinity); + Console.WriteLine("=== PASSED ==="); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/arithm64.cs b/tests/src/JIT/Methodical/NaN/arithm64.cs new file mode 100644 index 0000000..2b5d2b7 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/arithm64.cs @@ -0,0 +1,94 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +namespace JitTest +{ + using System; + + class Test + { + static void RunTests(double nan, double plusinf, double minusinf) + { + if (!Double.IsNaN(nan + nan)) + throw new Exception("! Double.IsNaN(nan + nan)"); + if (!Double.IsNaN(nan + plusinf)) + throw new Exception("! Double.IsNaN(nan + plusinf)"); + if (!Double.IsNaN(nan + minusinf)) + throw new Exception("! Double.IsNaN(nan + minusinf)"); + if (!Double.IsNaN(plusinf + nan)) + throw new Exception("! Double.IsNaN(plusinf + nan)"); + if (!Double.IsPositiveInfinity(plusinf + plusinf)) + throw new Exception("! Double.IsPositiveInfinity(plusinf + plusinf)"); + if (!Double.IsNaN(plusinf + minusinf)) + throw new Exception("! Double.IsNaN(plusinf + minusinf)"); + if (!Double.IsNaN(minusinf + nan)) + throw new Exception("! Double.IsNaN(minusinf + nan)"); + if (!Double.IsNaN(minusinf + plusinf)) + throw new Exception("! Double.IsNaN(minusinf + plusinf)"); + if (!Double.IsNegativeInfinity(minusinf + minusinf)) + throw new Exception("! Double.IsNegativeInfinity(minusinf + minusinf)"); + if (!Double.IsNaN(nan + nan)) + throw new Exception("! Double.IsNaN(nan + nan)"); + if (!Double.IsNaN(nan + plusinf)) + throw new Exception("! Double.IsNaN(nan + plusinf)"); + if (!Double.IsNaN(nan + minusinf)) + throw new Exception("! Double.IsNaN(nan + minusinf)"); + if (!Double.IsNaN(plusinf + nan)) + throw new Exception("! Double.IsNaN(plusinf + nan)"); + if (!Double.IsPositiveInfinity(plusinf + plusinf)) + throw new Exception("! Double.IsPositiveInfinity(plusinf + plusinf)"); + if (!Double.IsNaN(plusinf + minusinf)) + throw new Exception("! Double.IsNaN(plusinf + minusinf)"); + if (!Double.IsNaN(minusinf + nan)) + throw new Exception("! Double.IsNaN(minusinf + nan)"); + if (!Double.IsNaN(minusinf + plusinf)) + throw new Exception("! Double.IsNaN(minusinf + plusinf)"); + if (!Double.IsNegativeInfinity(minusinf + minusinf)) + throw new Exception("! Double.IsNegativeInfinity(minusinf + minusinf)"); + if (!Double.IsNaN(nan + nan)) + throw new Exception("! Double.IsNaN(nan + nan)"); + if (!Double.IsNaN(nan + plusinf)) + throw new Exception("! Double.IsNaN(nan + plusinf)"); + if (!Double.IsNaN(nan + minusinf)) + throw new Exception("! Double.IsNaN(nan + minusinf)"); + if (!Double.IsNaN(plusinf + nan)) + throw new Exception("! Double.IsNaN(plusinf + nan)"); + if (!Double.IsPositiveInfinity(plusinf + plusinf)) + throw new Exception("! Double.IsPositiveInfinity(plusinf + plusinf)"); + if (!Double.IsNaN(plusinf + minusinf)) + throw new Exception("! Double.IsNaN(plusinf + minusinf)"); + if (!Double.IsNaN(minusinf + nan)) + throw new Exception("! Double.IsNaN(minusinf + nan)"); + if (!Double.IsNaN(minusinf + plusinf)) + throw new Exception("! Double.IsNaN(minusinf + plusinf)"); + if (!Double.IsNegativeInfinity(minusinf + minusinf)) + throw new Exception("! Double.IsNegativeInfinity(minusinf + minusinf)"); + if (!Double.IsNaN(nan + nan)) + throw new Exception("! Double.IsNaN(nan + nan)"); + if (!Double.IsNaN(nan + plusinf)) + throw new Exception("! Double.IsNaN(nan + plusinf)"); + if (!Double.IsNaN(nan + minusinf)) + throw new Exception("! Double.IsNaN(nan + minusinf)"); + if (!Double.IsNaN(plusinf + nan)) + throw new Exception("! Double.IsNaN(plusinf + nan)"); + if (!Double.IsPositiveInfinity(plusinf + plusinf)) + throw new Exception("! Double.IsPositiveInfinity(plusinf + plusinf)"); + if (!Double.IsNaN(plusinf + minusinf)) + throw new Exception("! Double.IsNaN(plusinf + minusinf)"); + if (!Double.IsNaN(minusinf + nan)) + throw new Exception("! Double.IsNaN(minusinf + nan)"); + if (!Double.IsNaN(minusinf + plusinf)) + throw new Exception("! Double.IsNaN(minusinf + plusinf)"); + if (!Double.IsNegativeInfinity(minusinf + minusinf)) + throw new Exception("! Double.IsNegativeInfinity(minusinf + minusinf)"); + } + + static int Main() + { + RunTests(Double.NaN, Double.PositiveInfinity, Double.NegativeInfinity); + Console.WriteLine("=== PASSED ==="); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/cs_template.proj b/tests/src/JIT/Methodical/NaN/cs_template.proj new file mode 100644 index 0000000..adc2f21 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/cs_template.proj @@ -0,0 +1,42 @@ + + + + + Debug + AnyCPU + $(AssemblyName1) + 2.0 + {95DFC527-4DC1-495E-97D7-E94EE1F7140D} + Exe + Properties + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + $(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages + ..\..\ + true + 7a9bfb7d + + + + + + + + + False + + + + + + + + + + + + + + + + diff --git a/tests/src/JIT/Methodical/NaN/packages.config b/tests/src/JIT/Methodical/NaN/packages.config new file mode 100644 index 0000000..06d3d11 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/packages.config @@ -0,0 +1,6 @@ + + + + + + diff --git a/tests/src/JIT/Methodical/NaN/r4NaNadd.cs b/tests/src/JIT/Methodical/NaN/r4NaNadd.cs new file mode 100644 index 0000000..16c026c --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/r4NaNadd.cs @@ -0,0 +1,1103 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +class r4NaNadd +{ + + //user-defined class that overloads operator + + public class numHolder + { + float f_num; + public numHolder(float f_num) + { + this.f_num = Convert.ToSingle(f_num); + } + + public static float operator +(numHolder a, float b) + { + return a.f_num + b; + } + + public static float operator +(numHolder a, numHolder b) + { + return a.f_num + b.f_num; + } + + } + + static float f_s_test1_op1 = 0.0F; + static float f_s_test1_op2 = Single.NaN; + static float f_s_test2_op1 = Single.NegativeInfinity; + static float f_s_test2_op2 = Single.NaN; + static float f_s_test3_op1 = Single.NaN; + static float f_s_test3_op2 = 6.2F; + + public static float f_test1_f(String s) + { + if (s == "test1_op1") + return 0.0F; + else + return Single.NaN; + } + + public static float f_test2_f(String s) + { + if (s == "test2_op1") + return Single.NegativeInfinity; + else + return Single.NaN; + } + + public static float f_test3_f(String s) + { + if (s == "test3_op1") + return Single.NaN; + else + return 6.2F; + } + + class CL + { + public float f_cl_test1_op1 = 0.0F; + public float f_cl_test1_op2 = Single.NaN; + public float f_cl_test2_op1 = Single.NegativeInfinity; + public float f_cl_test2_op2 = Single.NaN; + public float f_cl_test3_op1 = Single.NaN; + public float f_cl_test3_op2 = 6.2F; + } + + struct VT + { + public float f_vt_test1_op1; + public float f_vt_test1_op2; + public float f_vt_test2_op1; + public float f_vt_test2_op2; + public float f_vt_test3_op1; + public float f_vt_test3_op2; + } + + public static int Main() + { + bool passed = true; + //initialize class + CL cl1 = new CL(); + //initialize struct + VT vt1; + vt1.f_vt_test1_op1 = 0.0F; + vt1.f_vt_test1_op2 = Single.NaN; + vt1.f_vt_test2_op1 = Single.NegativeInfinity; + vt1.f_vt_test2_op2 = Single.NaN; + vt1.f_vt_test3_op1 = Single.NaN; + vt1.f_vt_test3_op2 = 6.2F; + + float[] f_arr1d_test1_op1 = { 0, 0.0F }; + float[,] f_arr2d_test1_op1 = { { 0, 0.0F }, { 1, 1 } }; + float[, ,] f_arr3d_test1_op1 = { { { 0, 0.0F }, { 1, 1 } } }; + float[] f_arr1d_test1_op2 = { Single.NaN, 0, 1 }; + float[,] f_arr2d_test1_op2 = { { 0, Single.NaN }, { 1, 1 } }; + float[, ,] f_arr3d_test1_op2 = { { { 0, Single.NaN }, { 1, 1 } } }; + float[] f_arr1d_test2_op1 = { 0, Single.NegativeInfinity }; + float[,] f_arr2d_test2_op1 = { { 0, Single.NegativeInfinity }, { 1, 1 } }; + float[, ,] f_arr3d_test2_op1 = { { { 0, Single.NegativeInfinity }, { 1, 1 } } }; + float[] f_arr1d_test2_op2 = { Single.NaN, 0, 1 }; + float[,] f_arr2d_test2_op2 = { { 0, Single.NaN }, { 1, 1 } }; + float[, ,] f_arr3d_test2_op2 = { { { 0, Single.NaN }, { 1, 1 } } }; + float[] f_arr1d_test3_op1 = { 0, Single.NaN }; + float[,] f_arr2d_test3_op1 = { { 0, Single.NaN }, { 1, 1 } }; + float[, ,] f_arr3d_test3_op1 = { { { 0, Single.NaN }, { 1, 1 } } }; + float[] f_arr1d_test3_op2 = { 6.2F, 0, 1 }; + float[,] f_arr2d_test3_op2 = { { 0, 6.2F }, { 1, 1 } }; + float[, ,] f_arr3d_test3_op2 = { { { 0, 6.2F }, { 1, 1 } } }; + + int[,] index = { { 0, 0 }, { 1, 1 } }; + + { + float f_l_test1_op1 = 0.0F; + float f_l_test1_op2 = Single.NaN; + if (!Single.IsNaN(f_l_test1_op1 + f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 + f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 + f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 + cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 + vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 + f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 + f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 + f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 + f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 + f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 + f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 + cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 + vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 + f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 + f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 + f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") + f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") + f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") + f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") + cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") + vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") + f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") + f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") + f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 + f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 + f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 + f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 + cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 + vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 + f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 + f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 + f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 + f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 + f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 + f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 + cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 + vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 + f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 + f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 + f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] + f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] + f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] + f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] + cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] + vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] + f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] + f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] + f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] + f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] + f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] + f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] + cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] + vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] + f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] + f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] + f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 64 failed"); + passed = false; + } + } + + { + float f_l_test2_op1 = Single.NegativeInfinity; + float f_l_test2_op2 = Single.NaN; + if (!Single.IsNaN(f_l_test2_op1 + f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 + f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 + f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 + cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 + vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 + f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 + f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 + f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 + f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 + f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 + f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 + cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 + vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 + f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 + f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 + f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") + f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") + f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") + f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") + cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") + vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") + f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") + f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") + f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 + f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 + f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 + f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 + cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 + vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 + f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 + f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 + f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 + f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 + f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 + f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 + cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 + vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 + f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 + f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 + f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] + f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] + f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] + f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] + cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] + vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] + f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] + f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] + f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] + f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] + f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] + f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] + cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] + vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] + f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] + f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] + f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 64 failed"); + passed = false; + } + } + + { + float f_l_test3_op1 = Single.NaN; + float f_l_test3_op2 = 6.2F; + if (!Single.IsNaN(f_l_test3_op1 + f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 + f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 + f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 + cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 + vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 + f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 + f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 + f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 + f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 + f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 + f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 + cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 + vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 + f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 + f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 + f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") + f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") + f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") + f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") + cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") + vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") + f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") + f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") + f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 + f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 + f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 + f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 + cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 + vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 + f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 + f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 + f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 + f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 + f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 + f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 + cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 + vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 + f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 + f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 + f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] + f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] + f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] + f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] + cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] + vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] + f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] + f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] + f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] + f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] + f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] + f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] + cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] + vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] + f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] + f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] + f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 64 failed"); + passed = false; + } + } + + + if (!passed) + { + Console.WriteLine("FAILED"); + return 1; + } + else + { + Console.WriteLine("PASSED"); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/r4NaNdiv.cs b/tests/src/JIT/Methodical/NaN/r4NaNdiv.cs new file mode 100644 index 0000000..0c6d4f7 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/r4NaNdiv.cs @@ -0,0 +1,1107 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +class r4NaNdiv +{ + + //user-defined class that overloads operator / + public class numHolder + { + float f_num; + public numHolder(float f_num) + { + this.f_num = Convert.ToSingle(f_num); + } + + public static float operator /(numHolder a, float b) + { + return a.f_num / b; + } + + public static float operator /(numHolder a, numHolder b) + { + return a.f_num / b.f_num; + } + + } + + static float f_s_test1_op1 = 0; + static float f_s_test1_op2 = 0; + static float f_s_test2_op1 = Single.PositiveInfinity; + static float f_s_test2_op2 = Single.NegativeInfinity; + static float f_s_test3_op1 = Single.PositiveInfinity; + static float f_s_test3_op2 = Single.NaN; + + public static float f_test1_f(String s) + { + if (s == "test1_op1") + return 0; + else + return 0; + } + + public static float f_test2_f(String s) + { + if (s == "test2_op1") + return Single.PositiveInfinity; + else + return Single.NegativeInfinity; + } + + public static float f_test3_f(String s) + { + if (s == "test3_op1") + return Single.PositiveInfinity; + else + return Single.NaN; + } + + class CL + { + public float f_cl_test1_op1 = 0; + public float f_cl_test1_op2 = 0; + public float f_cl_test2_op1 = Single.PositiveInfinity; + public float f_cl_test2_op2 = Single.NegativeInfinity; + public float f_cl_test3_op1 = Single.PositiveInfinity; + public float f_cl_test3_op2 = Single.NaN; + } + + struct VT + { + public float f_vt_test1_op1; + public float f_vt_test1_op2; + public float f_vt_test2_op1; + public float f_vt_test2_op2; + public float f_vt_test3_op1; + public float f_vt_test3_op2; + } + + public static int Main() + { + bool passed = true; + //initialize class + CL cl1 = new CL(); + //initialize struct + VT vt1; + vt1.f_vt_test1_op1 = 0; + vt1.f_vt_test1_op2 = 0; + vt1.f_vt_test2_op1 = Single.PositiveInfinity; + vt1.f_vt_test2_op2 = Single.NegativeInfinity; + vt1.f_vt_test3_op1 = Single.PositiveInfinity; + vt1.f_vt_test3_op2 = Single.NaN; + + float[] f_arr1d_test1_op1 = { 0, 0 }; + float[,] f_arr2d_test1_op1 = { { 0, 0 }, { 1, 1 } }; + float[, ,] f_arr3d_test1_op1 = { { { 0, 0 }, { 1, 1 } } }; + + float[] f_arr1d_test1_op2 = { 0, 0, 1 }; + float[,] f_arr2d_test1_op2 = { { 0, 0 }, { 1, 1 } }; + float[, ,] f_arr3d_test1_op2 = { { { 0, 0 }, { 1, 1 } } }; + + float[] f_arr1d_test2_op1 = { 0, Single.PositiveInfinity }; + float[,] f_arr2d_test2_op1 = { { 0, Single.PositiveInfinity }, { 1, 1 } }; + float[, ,] f_arr3d_test2_op1 = { { { 0, Single.PositiveInfinity }, { 1, 1 } } }; + + float[] f_arr1d_test2_op2 = { Single.NegativeInfinity, 0, 1 }; + float[,] f_arr2d_test2_op2 = { { 0, Single.NegativeInfinity }, { 1, 1 } }; + float[, ,] f_arr3d_test2_op2 = { { { 0, Single.NegativeInfinity }, { 1, 1 } } }; + + float[] f_arr1d_test3_op1 = { 0, Single.PositiveInfinity }; + float[,] f_arr2d_test3_op1 = { { 0, Single.PositiveInfinity }, { 1, 1 } }; + float[, ,] f_arr3d_test3_op1 = { { { 0, Single.PositiveInfinity }, { 1, 1 } } }; + + float[] f_arr1d_test3_op2 = { Single.NaN, 0, 1 }; + float[,] f_arr2d_test3_op2 = { { 0, Single.NaN }, { 1, 1 } }; + float[, ,] f_arr3d_test3_op2 = { { { 0, Single.NaN }, { 1, 1 } } }; + + int[,] index = { { 0, 0 }, { 1, 1 } }; + + { + float f_l_test1_op1 = 0; + float f_l_test1_op2 = 0; + if (!Single.IsNaN(f_l_test1_op1 / f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 / f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 / f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 / cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 / vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 / f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 / f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 / f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 / f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 / f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 / f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 / cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 / vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 / f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 / f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 / f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") / f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") / f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") / f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") / cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") / vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") / f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") / f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") / f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 / f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 / f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 / f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 / cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 / vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 / f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 / f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 / f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 / f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 / f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 / f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 / cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 / vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 / f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 / f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 / f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] / f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] / f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] / f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] / cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] / vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] / f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] / f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] / f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] / f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] / f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] / f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] / cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] / vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] / f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] / f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] / f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 64 failed"); + passed = false; + } + } + + { + float f_l_test2_op1 = Single.PositiveInfinity; + float f_l_test2_op2 = Single.NegativeInfinity; + if (!Single.IsNaN(f_l_test2_op1 / f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 / f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 / f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 / cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 / vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 / f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 / f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 / f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 / f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 / f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 / f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 / cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 / vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 / f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 / f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 / f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") / f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") / f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") / f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") / cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") / vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") / f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") / f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") / f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 / f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 / f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 / f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 / cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 / vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 / f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 / f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 / f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 / f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 / f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 / f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 / cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 / vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 / f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 / f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 / f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] / f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] / f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] / f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] / cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] / vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] / f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] / f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] / f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] / f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] / f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] / f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] / cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] / vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] / f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] / f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] / f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 64 failed"); + passed = false; + } + } + + { + float f_l_test3_op1 = Single.PositiveInfinity; + float f_l_test3_op2 = Single.NaN; + if (!Single.IsNaN(f_l_test3_op1 / f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 / f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 / f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 / cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 / vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 / f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 / f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 / f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 / f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 / f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 / f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 / cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 / vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 / f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 / f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 / f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") / f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") / f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") / f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") / cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") / vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") / f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") / f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") / f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 / f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 / f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 / f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 / cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 / vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 / f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 / f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 / f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 / f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 / f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 / f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 / cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 / vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 / f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 / f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 / f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] / f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] / f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] / f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] / cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] / vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] / f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] / f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] / f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] / f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] / f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] / f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] / cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] / vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] / f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] / f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] / f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 64 failed"); + passed = false; + } + } + + if (!passed) + { + Console.WriteLine("FAILED"); + return 1; + } + else + { + Console.WriteLine("PASSED"); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/r4NaNmul.cs b/tests/src/JIT/Methodical/NaN/r4NaNmul.cs new file mode 100644 index 0000000..2df768f --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/r4NaNmul.cs @@ -0,0 +1,1107 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +class r4NaNmul +{ + + //user-defined class that overloads operator * + public class numHolder + { + float f_num; + public numHolder(float f_num) + { + this.f_num = Convert.ToSingle(f_num); + } + + public static float operator *(numHolder a, float b) + { + return a.f_num * b; + } + + public static float operator *(numHolder a, numHolder b) + { + return a.f_num * b.f_num; + } + + } + + static float f_s_test1_op1 = Single.PositiveInfinity; + static float f_s_test1_op2 = 0; + static float f_s_test2_op1 = Single.NegativeInfinity; + static float f_s_test2_op2 = 0; + static float f_s_test3_op1 = 3; + static float f_s_test3_op2 = Single.NaN; + + public static float f_test1_f(String s) + { + if (s == "test1_op1") + return Single.PositiveInfinity; + else + return 0; + } + + public static float f_test2_f(String s) + { + if (s == "test2_op1") + return Single.NegativeInfinity; + else + return 0; + } + + public static float f_test3_f(String s) + { + if (s == "test3_op1") + return 3; + else + return Single.NaN; + } + + class CL + { + public float f_cl_test1_op1 = Single.PositiveInfinity; + public float f_cl_test1_op2 = 0; + public float f_cl_test2_op1 = Single.NegativeInfinity; + public float f_cl_test2_op2 = 0; + public float f_cl_test3_op1 = 3; + public float f_cl_test3_op2 = Single.NaN; + } + + struct VT + { + public float f_vt_test1_op1; + public float f_vt_test1_op2; + public float f_vt_test2_op1; + public float f_vt_test2_op2; + public float f_vt_test3_op1; + public float f_vt_test3_op2; + } + + public static int Main() + { + bool passed = true; + //initialize class + CL cl1 = new CL(); + //initialize struct + VT vt1; + vt1.f_vt_test1_op1 = Single.PositiveInfinity; + vt1.f_vt_test1_op2 = 0; + vt1.f_vt_test2_op1 = Single.NegativeInfinity; + vt1.f_vt_test2_op2 = 0; + vt1.f_vt_test3_op1 = 3; + vt1.f_vt_test3_op2 = Single.NaN; + + float[] f_arr1d_test1_op1 = { 0, Single.PositiveInfinity }; + float[,] f_arr2d_test1_op1 = { { 0, Single.PositiveInfinity }, { 1, 1 } }; + float[, ,] f_arr3d_test1_op1 = { { { 0, Single.PositiveInfinity }, { 1, 1 } } }; + + float[] f_arr1d_test1_op2 = { 0, 0, 1 }; + float[,] f_arr2d_test1_op2 = { { 0, 0 }, { 1, 1 } }; + float[, ,] f_arr3d_test1_op2 = { { { 0, 0 }, { 1, 1 } } }; + + float[] f_arr1d_test2_op1 = { 0, Single.NegativeInfinity }; + float[,] f_arr2d_test2_op1 = { { 0, Single.NegativeInfinity }, { 1, 1 } }; + float[, ,] f_arr3d_test2_op1 = { { { 0, Single.NegativeInfinity }, { 1, 1 } } }; + + float[] f_arr1d_test2_op2 = { 0, 0, 1 }; + float[,] f_arr2d_test2_op2 = { { 0, 0 }, { 1, 1 } }; + float[, ,] f_arr3d_test2_op2 = { { { 0, 0 }, { 1, 1 } } }; + + float[] f_arr1d_test3_op1 = { 0, 3 }; + float[,] f_arr2d_test3_op1 = { { 0, 3 }, { 1, 1 } }; + float[, ,] f_arr3d_test3_op1 = { { { 0, 3 }, { 1, 1 } } }; + + float[] f_arr1d_test3_op2 = { Single.NaN, 0, 1 }; + float[,] f_arr2d_test3_op2 = { { 0, Single.NaN }, { 1, 1 } }; + float[, ,] f_arr3d_test3_op2 = { { { 0, Single.NaN }, { 1, 1 } } }; + + int[,] index = { { 0, 0 }, { 1, 1 } }; + + { + float f_l_test1_op1 = Single.PositiveInfinity; + float f_l_test1_op2 = 0; + if (!Single.IsNaN(f_l_test1_op1 * f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 * f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 * f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 * cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 * vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 * f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 * f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 * f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 * f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 * f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 * f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 * cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 * vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 * f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 * f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 * f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") * f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") * f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") * f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") * cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") * vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") * f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") * f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") * f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 * f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 * f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 * f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 * cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 * vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 * f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 * f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 * f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 * f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 * f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 * f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 * cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 * vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 * f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 * f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 * f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] * f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] * f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] * f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] * cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] * vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] * f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] * f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] * f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] * f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] * f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] * f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] * cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] * vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] * f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] * f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] * f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 64 failed"); + passed = false; + } + } + + { + float f_l_test2_op1 = Single.NegativeInfinity; + float f_l_test2_op2 = 0; + if (!Single.IsNaN(f_l_test2_op1 * f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 * f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 * f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 * cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 * vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 * f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 * f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 * f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 * f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 * f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 * f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 * cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 * vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 * f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 * f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 * f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") * f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") * f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") * f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") * cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") * vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") * f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") * f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") * f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 * f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 * f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 * f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 * cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 * vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 * f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 * f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 * f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 * f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 * f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 * f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 * cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 * vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 * f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 * f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 * f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] * f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] * f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] * f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] * cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] * vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] * f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] * f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] * f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] * f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] * f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] * f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] * cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] * vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] * f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] * f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] * f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 64 failed"); + passed = false; + } + } + + { + float f_l_test3_op1 = 3; + float f_l_test3_op2 = Single.NaN; + if (!Single.IsNaN(f_l_test3_op1 * f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 * f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 * f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 * cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 * vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 * f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 * f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 * f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 * f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 * f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 * f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 * cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 * vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 * f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 * f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 * f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") * f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") * f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") * f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") * cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") * vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") * f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") * f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") * f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 * f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 * f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 * f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 * cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 * vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 * f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 * f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 * f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 * f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 * f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 * f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 * cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 * vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 * f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 * f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 * f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] * f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] * f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] * f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] * cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] * vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] * f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] * f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] * f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] * f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] * f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] * f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] * cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] * vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] * f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] * f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] * f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 64 failed"); + passed = false; + } + } + + if (!passed) + { + Console.WriteLine("FAILED"); + return 1; + } + else + { + Console.WriteLine("PASSED"); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/r4NaNrem.cs b/tests/src/JIT/Methodical/NaN/r4NaNrem.cs new file mode 100644 index 0000000..f8ce691 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/r4NaNrem.cs @@ -0,0 +1,1107 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +class r4NaNrem +{ + + //user-defined class that overloads operator % + public class numHolder + { + float f_num; + public numHolder(float f_num) + { + this.f_num = Convert.ToSingle(f_num); + } + + public static float operator %(numHolder a, float b) + { + return a.f_num % b; + } + + public static float operator %(numHolder a, numHolder b) + { + return a.f_num % b.f_num; + } + + } + + static float f_s_test1_op1 = Single.NaN; + static float f_s_test1_op2 = 7.1234567F; + static float f_s_test2_op1 = -2.0F; + static float f_s_test2_op2 = 0.0F; + static float f_s_test3_op1 = Single.PositiveInfinity; + static float f_s_test3_op2 = 0.0F; + + public static float f_test1_f(String s) + { + if (s == "test1_op1") + return Single.NaN; + else + return 7.1234567F; + } + + public static float f_test2_f(String s) + { + if (s == "test2_op1") + return -2.0F; + else + return 0.0F; + } + + public static float f_test3_f(String s) + { + if (s == "test3_op1") + return Single.PositiveInfinity; + else + return 0.0F; + } + + class CL + { + public float f_cl_test1_op1 = Single.NaN; + public float f_cl_test1_op2 = 7.1234567F; + public float f_cl_test2_op1 = -2.0F; + public float f_cl_test2_op2 = 0.0F; + public float f_cl_test3_op1 = Single.PositiveInfinity; + public float f_cl_test3_op2 = 0.0F; + } + + struct VT + { + public float f_vt_test1_op1; + public float f_vt_test1_op2; + public float f_vt_test2_op1; + public float f_vt_test2_op2; + public float f_vt_test3_op1; + public float f_vt_test3_op2; + } + + public static int Main() + { + bool passed = true; + //initialize class + CL cl1 = new CL(); + //initialize struct + VT vt1; + vt1.f_vt_test1_op1 = Single.NaN; + vt1.f_vt_test1_op2 = 7.1234567F; + vt1.f_vt_test2_op1 = -2.0F; + vt1.f_vt_test2_op2 = 0.0F; + vt1.f_vt_test3_op1 = Single.PositiveInfinity; + vt1.f_vt_test3_op2 = 0.0F; + + float[] f_arr1d_test1_op1 = { 0, Single.NaN }; + float[,] f_arr2d_test1_op1 = { { 0, Single.NaN }, { 1, 1 } }; + float[, ,] f_arr3d_test1_op1 = { { { 0, Single.NaN }, { 1, 1 } } }; + + float[] f_arr1d_test1_op2 = { 7.1234567F, 0, 1 }; + float[,] f_arr2d_test1_op2 = { { 0, 7.1234567F }, { 1, 1 } }; + float[, ,] f_arr3d_test1_op2 = { { { 0, 7.1234567F }, { 1, 1 } } }; + + float[] f_arr1d_test2_op1 = { 0, -2.0F }; + float[,] f_arr2d_test2_op1 = { { 0, -2.0F }, { 1, 1 } }; + float[, ,] f_arr3d_test2_op1 = { { { 0, -2.0F }, { 1, 1 } } }; + + float[] f_arr1d_test2_op2 = { 0.0F, 0, 1 }; + float[,] f_arr2d_test2_op2 = { { 0, 0.0F }, { 1, 1 } }; + float[, ,] f_arr3d_test2_op2 = { { { 0, 0.0F }, { 1, 1 } } }; + + float[] f_arr1d_test3_op1 = { 0, Single.PositiveInfinity }; + float[,] f_arr2d_test3_op1 = { { 0, Single.PositiveInfinity }, { 1, 1 } }; + float[, ,] f_arr3d_test3_op1 = { { { 0, Single.PositiveInfinity }, { 1, 1 } } }; + + float[] f_arr1d_test3_op2 = { 0.0F, 0, 1 }; + float[,] f_arr2d_test3_op2 = { { 0, 0.0F }, { 1, 1 } }; + float[, ,] f_arr3d_test3_op2 = { { { 0, 0.0F }, { 1, 1 } } }; + + int[,] index = { { 0, 0 }, { 1, 1 } }; + + { + float f_l_test1_op1 = Single.NaN; + float f_l_test1_op2 = 7.1234567F; + if (!Single.IsNaN(f_l_test1_op1 % f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 % f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 % f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 % cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 % vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 % f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 % f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 % f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 % f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 % f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 % f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 % cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 % vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 % f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 % f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 % f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") % f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") % f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") % f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") % cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") % vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") % f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") % f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") % f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 % f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 % f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 % f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 % cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 % vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 % f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 % f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 % f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 % f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 % f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 % f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 % cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 % vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 % f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 % f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 % f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] % f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] % f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] % f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] % cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] % vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] % f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] % f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] % f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] % f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] % f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] % f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] % cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] % vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] % f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] % f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] % f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 64 failed"); + passed = false; + } + } + + { + float f_l_test2_op1 = -2.0F; + float f_l_test2_op2 = 0.0F; + if (!Single.IsNaN(f_l_test2_op1 % f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 % f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 % f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 % cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 % vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 % f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 % f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test2_op1 % f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 % f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 % f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 % f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 % cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 % vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 % f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 % f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test2_op1 % f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") % f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") % f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") % f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") % cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") % vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") % f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") % f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("test2_op1") % f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 % f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 % f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 % f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 % cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 % vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 % f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 % f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test2_op1 % f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 % f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 % f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 % f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 % cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 % vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 % f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 % f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test2_op1 % f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] % f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] % f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] % f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] % cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] % vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] % f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] % f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test2_op1[1] % f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] % f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] % f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] % f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] % cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] % vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] % f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] % f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test2_op1[index[0, 1], index[1, 0]] % f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % f_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % f_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % f_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % cl1.f_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % vt1.f_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % f_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % f_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % f_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 64 failed"); + passed = false; + } + } + + { + float f_l_test3_op1 = Single.PositiveInfinity; + float f_l_test3_op2 = 0.0F; + if (!Single.IsNaN(f_l_test3_op1 % f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 % f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 % f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 % cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 % vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 % f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 % f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 % f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 % f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 % f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 % f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 % cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 % vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 % f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 % f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 % f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") % f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") % f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") % f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") % cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") % vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") % f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") % f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") % f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 % f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 % f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 % f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 % cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 % vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 % f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 % f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 % f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 % f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 % f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 % f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 % cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 % vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 % f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 % f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 % f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] % f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] % f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] % f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] % cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] % vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] % f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] % f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] % f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] % f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] % f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] % f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] % cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] % vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] % f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] % f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] % f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 64 failed"); + passed = false; + } + } + + if (!passed) + { + Console.WriteLine("FAILED"); + return 1; + } + else + { + Console.WriteLine("PASSED"); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/r4NaNsub.cs b/tests/src/JIT/Methodical/NaN/r4NaNsub.cs new file mode 100644 index 0000000..8514509 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/r4NaNsub.cs @@ -0,0 +1,1108 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +class r4NaNsub +{ + + //user-defined class that overloads operator - + public class numHolder + { + float f_num; + public numHolder(float f_num) + { + this.f_num = Convert.ToSingle(f_num); + } + + public static float operator -(numHolder a, float b) + { + return a.f_num - b; + } + + public static float operator -(numHolder a, numHolder b) + { + return a.f_num - b.f_num; + } + + } + + static float f_s_test1_op1 = Single.NegativeInfinity; + static float f_s_test1_op2 = Single.NegativeInfinity; + static float f_s_Test2_op1 = -3.4F; + static float f_s_Test2_op2 = Single.NaN; + static float f_s_test3_op1 = Single.NaN; + static float f_s_test3_op2 = Single.NaN; + + public static float f_test1_f(String s) + { + if (s == "test1_op1") + return Single.NegativeInfinity; + else + return Single.NegativeInfinity; + } + + public static float f_test2_f(String s) + { + if (s == "Test2_op1") + return -3.4F; + else + return Single.NaN; + } + + public static float f_test3_f(String s) + { + if (s == "test3_op1") + return Single.NaN; + else + return Single.NaN; + } + + class CL + { + public float f_cl_test1_op1 = Single.NegativeInfinity; + public float f_cl_test1_op2 = Single.NegativeInfinity; + public float f_cl_Test2_op1 = -3.4F; + public float f_cl_Test2_op2 = Single.NaN; + public float f_cl_test3_op1 = Single.NaN; + public float f_cl_test3_op2 = Single.NaN; + } + + struct VT + { + public float f_vt_test1_op1; + public float f_vt_test1_op2; + public float f_vt_Test2_op1; + public float f_vt_Test2_op2; + public float f_vt_test3_op1; + public float f_vt_test3_op2; + } + + public static int Main() + { + bool passed = true; + //initialize class + CL cl1 = new CL(); + //initialize struct + VT vt1; + vt1.f_vt_test1_op1 = Single.NegativeInfinity; + vt1.f_vt_test1_op2 = Single.NegativeInfinity; + vt1.f_vt_Test2_op1 = -3.4F; + vt1.f_vt_Test2_op2 = Single.NaN; + vt1.f_vt_test3_op1 = Single.NaN; + vt1.f_vt_test3_op2 = Single.NaN; + + float[] f_arr1d_test1_op1 = { 0, Single.NegativeInfinity }; + float[,] f_arr2d_test1_op1 = { { 0, Single.NegativeInfinity }, { 1, 1 } }; + float[, ,] f_arr3d_test1_op1 = { { { 0, Single.NegativeInfinity }, { 1, 1 } } }; + + float[] f_arr1d_test1_op2 = { Single.NegativeInfinity, 0, 1 }; + float[,] f_arr2d_test1_op2 = { { 0, Single.NegativeInfinity }, { 1, 1 } }; + float[, ,] f_arr3d_test1_op2 = { { { 0, Single.NegativeInfinity }, { 1, 1 } } }; + + float[] f_arr1d_Test2_op1 = { 0, -3.4F }; + float[,] f_arr2d_Test2_op1 = { { 0, -3.4F }, { 1, 1 } }; + float[, ,] f_arr3d_Test2_op1 = { { { 0, -3.4F }, { 1, 1 } } }; + + float[] f_arr1d_Test2_op2 = { Single.NaN, 0, 1 }; + float[,] f_arr2d_Test2_op2 = { { 0, Single.NaN }, { 1, 1 } }; + float[, ,] f_arr3d_Test2_op2 = { { { 0, Single.NaN }, { 1, 1 } } }; + + float[] f_arr1d_test3_op1 = { 0, Single.NaN }; + float[,] f_arr2d_test3_op1 = { { 0, Single.NaN }, { 1, 1 } }; + float[, ,] f_arr3d_test3_op1 = { { { 0, Single.NaN }, { 1, 1 } } }; + + float[] f_arr1d_test3_op2 = { Single.NaN, 0, 1 }; + float[,] f_arr2d_test3_op2 = { { 0, Single.NaN }, { 1, 1 } }; + float[, ,] f_arr3d_test3_op2 = { { { 0, Single.NaN }, { 1, 1 } } }; + + int[,] index = { { 0, 0 }, { 1, 1 } }; + + { + float f_l_test1_op1 = Single.NegativeInfinity; + float f_l_test1_op2 = Single.NegativeInfinity; + if (!Single.IsNaN(f_l_test1_op1 - f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 - f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 - f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 - cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 - vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 - f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 - f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test1_op1 - f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 - f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 - f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 - f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 - cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 - vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 - f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 - f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test1_op1 - f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") - f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") - f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") - f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") - cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") - vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") - f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") - f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test1_f("test1_op1") - f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 - f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 - f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 - f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 - cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 - vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 - f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 - f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test1_op1 - f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 - f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 - f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 - f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 - cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 - vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 - f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 - f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test1_op1 - f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] - f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] - f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] - f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] - cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] - vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] - f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] - f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test1_op1[1] - f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] - f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] - f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] - f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] - cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] - vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] - f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] - f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test1_op1[index[0, 1], index[1, 0]] - f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - f_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - f_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - f_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - cl1.f_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - vt1.f_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - f_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - f_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - f_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 64 failed"); + passed = false; + } + } + + { + float f_l_Test2_op1 = -3.4F; + float f_l_Test2_op2 = Single.NaN; + if (!Single.IsNaN(f_l_Test2_op1 - f_l_Test2_op2)) + { + Console.WriteLine("Test2_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_Test2_op1 - f_s_Test2_op2)) + { + Console.WriteLine("Test2_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_Test2_op1 - f_test2_f("Test2_op2"))) + { + Console.WriteLine("Test2_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_Test2_op1 - cl1.f_cl_Test2_op2)) + { + Console.WriteLine("Test2_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_Test2_op1 - vt1.f_vt_Test2_op2)) + { + Console.WriteLine("Test2_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_Test2_op1 - f_arr1d_Test2_op2[0])) + { + Console.WriteLine("Test2_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_Test2_op1 - f_arr2d_Test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_Test2_op1 - f_arr3d_Test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_Test2_op1 - f_l_Test2_op2)) + { + Console.WriteLine("Test2_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_Test2_op1 - f_s_Test2_op2)) + { + Console.WriteLine("Test2_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_Test2_op1 - f_test2_f("Test2_op2"))) + { + Console.WriteLine("Test2_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_Test2_op1 - cl1.f_cl_Test2_op2)) + { + Console.WriteLine("Test2_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_Test2_op1 - vt1.f_vt_Test2_op2)) + { + Console.WriteLine("Test2_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_Test2_op1 - f_arr1d_Test2_op2[0])) + { + Console.WriteLine("Test2_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_Test2_op1 - f_arr2d_Test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_Test2_op1 - f_arr3d_Test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("Test2_op1") - f_l_Test2_op2)) + { + Console.WriteLine("Test2_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("Test2_op1") - f_s_Test2_op2)) + { + Console.WriteLine("Test2_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("Test2_op1") - f_test2_f("Test2_op2"))) + { + Console.WriteLine("Test2_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("Test2_op1") - cl1.f_cl_Test2_op2)) + { + Console.WriteLine("Test2_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("Test2_op1") - vt1.f_vt_Test2_op2)) + { + Console.WriteLine("Test2_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("Test2_op1") - f_arr1d_Test2_op2[0])) + { + Console.WriteLine("Test2_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("Test2_op1") - f_arr2d_Test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test2_f("Test2_op1") - f_arr3d_Test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_Test2_op1 - f_l_Test2_op2)) + { + Console.WriteLine("Test2_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_Test2_op1 - f_s_Test2_op2)) + { + Console.WriteLine("Test2_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_Test2_op1 - f_test2_f("Test2_op2"))) + { + Console.WriteLine("Test2_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_Test2_op1 - cl1.f_cl_Test2_op2)) + { + Console.WriteLine("Test2_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_Test2_op1 - vt1.f_vt_Test2_op2)) + { + Console.WriteLine("Test2_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_Test2_op1 - f_arr1d_Test2_op2[0])) + { + Console.WriteLine("Test2_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_Test2_op1 - f_arr2d_Test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_Test2_op1 - f_arr3d_Test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_Test2_op1 - f_l_Test2_op2)) + { + Console.WriteLine("Test2_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_Test2_op1 - f_s_Test2_op2)) + { + Console.WriteLine("Test2_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_Test2_op1 - f_test2_f("Test2_op2"))) + { + Console.WriteLine("Test2_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_Test2_op1 - cl1.f_cl_Test2_op2)) + { + Console.WriteLine("Test2_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_Test2_op1 - vt1.f_vt_Test2_op2)) + { + Console.WriteLine("Test2_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_Test2_op1 - f_arr1d_Test2_op2[0])) + { + Console.WriteLine("Test2_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_Test2_op1 - f_arr2d_Test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_Test2_op1 - f_arr3d_Test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_Test2_op1[1] - f_l_Test2_op2)) + { + Console.WriteLine("Test2_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_Test2_op1[1] - f_s_Test2_op2)) + { + Console.WriteLine("Test2_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_Test2_op1[1] - f_test2_f("Test2_op2"))) + { + Console.WriteLine("Test2_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_Test2_op1[1] - cl1.f_cl_Test2_op2)) + { + Console.WriteLine("Test2_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_Test2_op1[1] - vt1.f_vt_Test2_op2)) + { + Console.WriteLine("Test2_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_Test2_op1[1] - f_arr1d_Test2_op2[0])) + { + Console.WriteLine("Test2_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_Test2_op1[1] - f_arr2d_Test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_Test2_op1[1] - f_arr3d_Test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_Test2_op1[index[0, 1], index[1, 0]] - f_l_Test2_op2)) + { + Console.WriteLine("Test2_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_Test2_op1[index[0, 1], index[1, 0]] - f_s_Test2_op2)) + { + Console.WriteLine("Test2_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_Test2_op1[index[0, 1], index[1, 0]] - f_test2_f("Test2_op2"))) + { + Console.WriteLine("Test2_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_Test2_op1[index[0, 1], index[1, 0]] - cl1.f_cl_Test2_op2)) + { + Console.WriteLine("Test2_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_Test2_op1[index[0, 1], index[1, 0]] - vt1.f_vt_Test2_op2)) + { + Console.WriteLine("Test2_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_Test2_op1[index[0, 1], index[1, 0]] - f_arr1d_Test2_op2[0])) + { + Console.WriteLine("Test2_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_Test2_op1[index[0, 1], index[1, 0]] - f_arr2d_Test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_Test2_op1[index[0, 1], index[1, 0]] - f_arr3d_Test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_Test2_op1[index[0, 0], 0, index[1, 1]] - f_l_Test2_op2)) + { + Console.WriteLine("Test2_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_Test2_op1[index[0, 0], 0, index[1, 1]] - f_s_Test2_op2)) + { + Console.WriteLine("Test2_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_Test2_op1[index[0, 0], 0, index[1, 1]] - f_test2_f("Test2_op2"))) + { + Console.WriteLine("Test2_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_Test2_op1[index[0, 0], 0, index[1, 1]] - cl1.f_cl_Test2_op2)) + { + Console.WriteLine("Test2_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_Test2_op1[index[0, 0], 0, index[1, 1]] - vt1.f_vt_Test2_op2)) + { + Console.WriteLine("Test2_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_Test2_op1[index[0, 0], 0, index[1, 1]] - f_arr1d_Test2_op2[0])) + { + Console.WriteLine("Test2_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_Test2_op1[index[0, 0], 0, index[1, 1]] - f_arr2d_Test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_Test2_op1[index[0, 0], 0, index[1, 1]] - f_arr3d_Test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 64 failed"); + passed = false; + } + } + + { + float f_l_test3_op1 = Single.NaN; + float f_l_test3_op2 = Single.NaN; + if (!Single.IsNaN(f_l_test3_op1 - f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 1 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 - f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 2 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 - f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 3 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 - cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 4 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 - vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 5 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 - f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 6 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 - f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 7 failed"); + passed = false; + } + if (!Single.IsNaN(f_l_test3_op1 - f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 8 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 - f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 9 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 - f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 10 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 - f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 11 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 - cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 12 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 - vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 13 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 - f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 14 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 - f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 15 failed"); + passed = false; + } + if (!Single.IsNaN(f_s_test3_op1 - f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 16 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") - f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 17 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") - f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 18 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") - f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 19 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") - cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 20 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") - vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 21 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") - f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 22 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") - f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 23 failed"); + passed = false; + } + if (!Single.IsNaN(f_test3_f("test3_op1") - f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 24 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 - f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 25 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 - f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 26 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 - f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 27 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 - cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 28 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 - vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 29 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 - f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 30 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 - f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 31 failed"); + passed = false; + } + if (!Single.IsNaN(cl1.f_cl_test3_op1 - f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 32 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 - f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 33 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 - f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 34 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 - f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 35 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 - cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 36 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 - vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 37 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 - f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 38 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 - f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 39 failed"); + passed = false; + } + if (!Single.IsNaN(vt1.f_vt_test3_op1 - f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 40 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] - f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 41 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] - f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 42 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] - f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 43 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] - cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 44 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] - vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 45 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] - f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 46 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] - f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 47 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr1d_test3_op1[1] - f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 48 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] - f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 49 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] - f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 50 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] - f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 51 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] - cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 52 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] - vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 53 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] - f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 54 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] - f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 55 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr2d_test3_op1[index[0, 1], index[1, 0]] - f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 56 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - f_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 57 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - f_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 58 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - f_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 59 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - cl1.f_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 60 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - vt1.f_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 61 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - f_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 62 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - f_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 63 failed"); + passed = false; + } + if (!Single.IsNaN(f_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - f_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 64 failed"); + passed = false; + } + } + + + if (!passed) + { + Console.WriteLine("FAILED"); + return 1; + } + else + { + Console.WriteLine("PASSED"); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/r8NaNadd.cs b/tests/src/JIT/Methodical/NaN/r8NaNadd.cs new file mode 100644 index 0000000..b81f1e3 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/r8NaNadd.cs @@ -0,0 +1,1106 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +class r8NaNadd +{ + + //user-defined class that overloads operator + + public class numHolder + { + double d_num; + public numHolder(double d_num) + { + this.d_num = Convert.ToSingle(d_num); + } + + public static double operator +(numHolder a, double b) + { + return a.d_num + b; + } + + public static double operator +(numHolder a, numHolder b) + { + return a.d_num + b.d_num; + } + + } + + static double d_s_test1_op1 = Double.NegativeInfinity; + static double d_s_test1_op2 = Double.PositiveInfinity; + static double d_s_test2_op1 = Double.PositiveInfinity; + static double d_s_test2_op2 = Double.NaN; + static double d_s_test3_op1 = Double.NaN; + static double d_s_test3_op2 = Double.NaN; + + public static double d_test1_f(String s) + { + if (s == "test1_op1") + return Double.NegativeInfinity; + else + return Double.PositiveInfinity; + } + + public static double d_test2_f(String s) + { + if (s == "test2_op1") + return Double.PositiveInfinity; + else + return Double.NaN; + } + + public static double d_test3_f(String s) + { + if (s == "test3_op1") + return Double.NaN; + else + return Double.NaN; + } + + class CL + { + public double d_cl_test1_op1 = Double.NegativeInfinity; + public double d_cl_test1_op2 = Double.PositiveInfinity; + public double d_cl_test2_op1 = Double.PositiveInfinity; + public double d_cl_test2_op2 = Double.NaN; + public double d_cl_test3_op1 = Double.NaN; + public double d_cl_test3_op2 = Double.NaN; + } + + struct VT + { + public double d_vt_test1_op1; + public double d_vt_test1_op2; + public double d_vt_test2_op1; + public double d_vt_test2_op2; + public double d_vt_test3_op1; + public double d_vt_test3_op2; + } + public static int Main() + { + bool passed = true; + //initialize class + CL cl1 = new CL(); + //initialize struct + VT vt1; + vt1.d_vt_test1_op1 = Double.NegativeInfinity; + vt1.d_vt_test1_op2 = Double.PositiveInfinity; + vt1.d_vt_test2_op1 = Double.PositiveInfinity; + vt1.d_vt_test2_op2 = Double.NaN; + vt1.d_vt_test3_op1 = Double.NaN; + vt1.d_vt_test3_op2 = Double.NaN; + + double[] d_arr1d_test1_op1 = { 0, Double.NegativeInfinity }; + double[,] d_arr2d_test1_op1 = { { 0, Double.NegativeInfinity }, { 1, 1 } }; + double[, ,] d_arr3d_test1_op1 = { { { 0, Double.NegativeInfinity }, { 1, 1 } } }; + + double[] d_arr1d_test1_op2 = { Double.PositiveInfinity, 0, 1 }; + double[,] d_arr2d_test1_op2 = { { 0, Double.PositiveInfinity }, { 1, 1 } }; + double[, ,] d_arr3d_test1_op2 = { { { 0, Double.PositiveInfinity }, { 1, 1 } } }; + + double[] d_arr1d_test2_op1 = { 0, Double.PositiveInfinity }; + double[,] d_arr2d_test2_op1 = { { 0, Double.PositiveInfinity }, { 1, 1 } }; + double[, ,] d_arr3d_test2_op1 = { { { 0, Double.PositiveInfinity }, { 1, 1 } } }; + + double[] d_arr1d_test2_op2 = { Double.NaN, 0, 1 }; + double[,] d_arr2d_test2_op2 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test2_op2 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test3_op1 = { 0, Double.NaN }; + double[,] d_arr2d_test3_op1 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test3_op1 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test3_op2 = { Double.NaN, 0, 1 }; + double[,] d_arr2d_test3_op2 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test3_op2 = { { { 0, Double.NaN }, { 1, 1 } } }; + + int[,] index = { { 0, 0 }, { 1, 1 } }; + + { + double d_l_test1_op1 = Double.NegativeInfinity; + double d_l_test1_op2 = Double.PositiveInfinity; + if (!Double.IsNaN(d_l_test1_op1 + d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 + d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 + d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 + cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 + vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 + d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 + d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 + d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 + d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 + d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 + d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 + cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 + vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 + d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 + d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 + d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") + d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") + d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") + d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") + cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") + vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") + d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") + d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") + d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 + d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 + d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 + d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 + cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 + vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 + d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 + d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 + d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 + d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 + d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 + d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 + cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 + vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 + d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 + d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 + d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] + d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] + d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] + d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] + cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] + vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] + d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] + d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] + d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] + d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] + d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] + d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] + cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] + vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] + d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] + d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] + d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] + d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 64 failed"); + passed = false; + } + } + + { + double d_l_test2_op1 = Double.PositiveInfinity; + double d_l_test2_op2 = Double.NaN; + if (!Double.IsNaN(d_l_test2_op1 + d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 + d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 + d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 + cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 + vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 + d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 + d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 + d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 + d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 + d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 + d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 + cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 + vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 + d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 + d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 + d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") + d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") + d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") + d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") + cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") + vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") + d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") + d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") + d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 + d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 + d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 + d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 + cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 + vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 + d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 + d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 + d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 + d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 + d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 + d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 + cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 + vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 + d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 + d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 + d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] + d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] + d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] + d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] + cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] + vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] + d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] + d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] + d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] + d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] + d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] + d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] + cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] + vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] + d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] + d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] + d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] + d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 64 failed"); + passed = false; + } + } + + { + double d_l_test3_op1 = Double.NaN; + double d_l_test3_op2 = Double.NaN; + if (!Double.IsNaN(d_l_test3_op1 + d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 + d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 + d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 + cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 + vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 + d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 + d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 + d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 + d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 + d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 + d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 + cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 + vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 + d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 + d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 + d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") + d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") + d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") + d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") + cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") + vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") + d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") + d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") + d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 + d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 + d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 + d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 + cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 + vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 + d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 + d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 + d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 + d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 + d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 + d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 + cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 + vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 + d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 + d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 + d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] + d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] + d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] + d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] + cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] + vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] + d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] + d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] + d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] + d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] + d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] + d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] + cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] + vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] + d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] + d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] + d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] + d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 64 failed"); + passed = false; + } + } + + if (!passed) + { + Console.WriteLine("FAILED"); + return 1; + } + else + { + Console.WriteLine("PASSED"); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/r8NaNdiv.cs b/tests/src/JIT/Methodical/NaN/r8NaNdiv.cs new file mode 100644 index 0000000..74b161d --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/r8NaNdiv.cs @@ -0,0 +1,1108 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +class r8NaNdiv +{ + + //user-defined class that overloads operator / + public class numHolder + { + double d_num; + public numHolder(double d_num) + { + this.d_num = Convert.ToDouble(d_num); + } + + public static double operator /(numHolder a, double b) + { + return a.d_num / b; + } + + public static double operator /(numHolder a, numHolder b) + { + return a.d_num / b.d_num; + } + + } + + static double d_s_test1_op1 = Double.NaN; + static double d_s_test1_op2 = Double.NaN; + static double d_s_test2_op1 = 5.12345678F; + static double d_s_test2_op2 = Double.NaN; + static double d_s_test3_op1 = Double.NaN; + static double d_s_test3_op2 = 0; + + public static double d_test1_f(String s) + { + if (s == "test1_op1") + return Double.NaN; + else + return Double.NaN; + } + + public static double d_test2_f(String s) + { + if (s == "test2_op1") + return 5.12345678F; + else + return Double.NaN; + } + + public static double d_test3_f(String s) + { + if (s == "test3_op1") + return Double.NaN; + else + return 0; + } + + class CL + { + public double d_cl_test1_op1 = Double.NaN; + public double d_cl_test1_op2 = Double.NaN; + public double d_cl_test2_op1 = 5.12345678F; + public double d_cl_test2_op2 = Double.NaN; + public double d_cl_test3_op1 = Double.NaN; + public double d_cl_test3_op2 = 0; + } + + struct VT + { + public double d_vt_test1_op1; + public double d_vt_test1_op2; + public double d_vt_test2_op1; + public double d_vt_test2_op2; + public double d_vt_test3_op1; + public double d_vt_test3_op2; + } + + public static int Main() + { + bool passed = true; + //initialize class + CL cl1 = new CL(); + //initialize struct + VT vt1; + vt1.d_vt_test1_op1 = Double.NaN; + vt1.d_vt_test1_op2 = Double.NaN; + vt1.d_vt_test2_op1 = 5.12345678F; + vt1.d_vt_test2_op2 = Double.NaN; + vt1.d_vt_test3_op1 = Double.NaN; + vt1.d_vt_test3_op2 = 0; + + double[] d_arr1d_test1_op1 = { 0, Double.NaN }; + double[,] d_arr2d_test1_op1 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test1_op1 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test1_op2 = { Double.NaN, 0, 1 }; + double[,] d_arr2d_test1_op2 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test1_op2 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test2_op1 = { 0, 5.12345678F }; + double[,] d_arr2d_test2_op1 = { { 0, 5.12345678F }, { 1, 1 } }; + double[, ,] d_arr3d_test2_op1 = { { { 0, 5.12345678F }, { 1, 1 } } }; + + double[] d_arr1d_test2_op2 = { Double.NaN, 0, 1 }; + double[,] d_arr2d_test2_op2 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test2_op2 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test3_op1 = { 0, Double.NaN }; + double[,] d_arr2d_test3_op1 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test3_op1 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test3_op2 = { 0, 0, 1 }; + double[,] d_arr2d_test3_op2 = { { 0, 0 }, { 1, 1 } }; + double[, ,] d_arr3d_test3_op2 = { { { 0, 0 }, { 1, 1 } } }; + + int[,] index = { { 0, 0 }, { 1, 1 } }; + + { + double d_l_test1_op1 = Double.NaN; + double d_l_test1_op2 = Double.NaN; + if (!Double.IsNaN(d_l_test1_op1 / d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 / d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 / d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 / cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 / vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 / d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 / d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 / d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 / d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 / d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 / d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 / cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 / vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 / d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 / d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 / d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") / d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") / d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") / d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") / cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") / vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") / d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") / d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") / d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 / d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 / d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 / d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 / cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 / vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 / d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 / d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 / d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 / d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 / d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 / d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 / cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 / vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 / d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 / d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 / d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] / d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] / d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] / d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] / cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] / vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] / d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] / d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] / d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] / d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] / d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] / d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] / cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] / vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] / d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] / d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] / d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] / d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 64 failed"); + passed = false; + } + } + + { + double d_l_test2_op1 = 5.12345678F; + double d_l_test2_op2 = Double.NaN; + if (!Double.IsNaN(d_l_test2_op1 / d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 / d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 / d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 / cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 / vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 / d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 / d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 / d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 / d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 / d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 / d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 / cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 / vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 / d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 / d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 / d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") / d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") / d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") / d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") / cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") / vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") / d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") / d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") / d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 / d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 / d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 / d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 / cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 / vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 / d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 / d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 / d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 / d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 / d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 / d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 / cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 / vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 / d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 / d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 / d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] / d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] / d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] / d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] / cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] / vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] / d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] / d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] / d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] / d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] / d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] / d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] / cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] / vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] / d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] / d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] / d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] / d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 64 failed"); + passed = false; + } + } + + { + double d_l_test3_op1 = Double.NaN; + double d_l_test3_op2 = 0; + if (!Double.IsNaN(d_l_test3_op1 / d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 / d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 / d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 / cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 / vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 / d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 / d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 / d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 / d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 / d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 / d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 / cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 / vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 / d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 / d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 / d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") / d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") / d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") / d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") / cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") / vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") / d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") / d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") / d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 / d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 / d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 / d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 / cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 / vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 / d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 / d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 / d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 / d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 / d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 / d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 / cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 / vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 / d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 / d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 / d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] / d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] / d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] / d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] / cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] / vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] / d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] / d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] / d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] / d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] / d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] / d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] / cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] / vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] / d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] / d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] / d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] / d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 64 failed"); + passed = false; + } + } + + + if (!passed) + { + Console.WriteLine("FAILED"); + return 1; + } + else + { + Console.WriteLine("PASSED"); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/r8NaNmul.cs b/tests/src/JIT/Methodical/NaN/r8NaNmul.cs new file mode 100644 index 0000000..c310f15 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/r8NaNmul.cs @@ -0,0 +1,1107 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +class r8NaNmul +{ + + //user-defined class that overloads operator * + public class numHolder + { + double d_num; + public numHolder(double d_num) + { + this.d_num = Convert.ToDouble(d_num); + } + + public static double operator *(numHolder a, double b) + { + return a.d_num * b; + } + + public static double operator *(numHolder a, numHolder b) + { + return a.d_num * b.d_num; + } + + } + + static double d_s_test1_op1 = Double.NegativeInfinity; + static double d_s_test1_op2 = Double.NaN; + static double d_s_test2_op1 = Double.NaN; + static double d_s_test2_op2 = Double.PositiveInfinity; + static double d_s_test3_op1 = Double.NaN; + static double d_s_test3_op2 = 0; + + public static double d_test1_f(String s) + { + if (s == "test1_op1") + return Double.NegativeInfinity; + else + return Double.NaN; + } + + public static double d_test2_f(String s) + { + if (s == "test2_op1") + return Double.NaN; + else + return Double.PositiveInfinity; + } + + public static double d_test3_f(String s) + { + if (s == "test3_op1") + return Double.NaN; + else + return 0; + } + + class CL + { + public double d_cl_test1_op1 = Double.NegativeInfinity; + public double d_cl_test1_op2 = Double.NaN; + public double d_cl_test2_op1 = Double.NaN; + public double d_cl_test2_op2 = Double.PositiveInfinity; + public double d_cl_test3_op1 = Double.NaN; + public double d_cl_test3_op2 = 0; + } + + struct VT + { + public double d_vt_test1_op1; + public double d_vt_test1_op2; + public double d_vt_test2_op1; + public double d_vt_test2_op2; + public double d_vt_test3_op1; + public double d_vt_test3_op2; + } + + public static int Main() + { + bool passed = true; + //initialize class + CL cl1 = new CL(); + //initialize struct + VT vt1; + vt1.d_vt_test1_op1 = Double.NegativeInfinity; + vt1.d_vt_test1_op2 = Double.NaN; + vt1.d_vt_test2_op1 = Double.NaN; + vt1.d_vt_test2_op2 = Double.PositiveInfinity; + vt1.d_vt_test3_op1 = Double.NaN; + vt1.d_vt_test3_op2 = 0; + + double[] d_arr1d_test1_op1 = { 0, Double.NegativeInfinity }; + double[,] d_arr2d_test1_op1 = { { 0, Double.NegativeInfinity }, { 1, 1 } }; + double[, ,] d_arr3d_test1_op1 = { { { 0, Double.NegativeInfinity }, { 1, 1 } } }; + + double[] d_arr1d_test1_op2 = { Double.NaN, 0, 1 }; + double[,] d_arr2d_test1_op2 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test1_op2 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test2_op1 = { 0, Double.NaN }; + double[,] d_arr2d_test2_op1 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test2_op1 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test2_op2 = { Double.PositiveInfinity, 0, 1 }; + double[,] d_arr2d_test2_op2 = { { 0, Double.PositiveInfinity }, { 1, 1 } }; + double[, ,] d_arr3d_test2_op2 = { { { 0, Double.PositiveInfinity }, { 1, 1 } } }; + + double[] d_arr1d_test3_op1 = { 0, Double.NaN }; + double[,] d_arr2d_test3_op1 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test3_op1 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test3_op2 = { 0, 0, 1 }; + double[,] d_arr2d_test3_op2 = { { 0, 0 }, { 1, 1 } }; + double[, ,] d_arr3d_test3_op2 = { { { 0, 0 }, { 1, 1 } } }; + + int[,] index = { { 0, 0 }, { 1, 1 } }; + + { + double d_l_test1_op1 = Double.NegativeInfinity; + double d_l_test1_op2 = Double.NaN; + if (!Double.IsNaN(d_l_test1_op1 * d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 * d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 * d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 * cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 * vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 * d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 * d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 * d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 * d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 * d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 * d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 * cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 * vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 * d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 * d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 * d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") * d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") * d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") * d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") * cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") * vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") * d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") * d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") * d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 * d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 * d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 * d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 * cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 * vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 * d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 * d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 * d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 * d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 * d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 * d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 * cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 * vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 * d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 * d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 * d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] * d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] * d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] * d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] * cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] * vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] * d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] * d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] * d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] * d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] * d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] * d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] * cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] * vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] * d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] * d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] * d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] * d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 64 failed"); + passed = false; + } + } + + { + double d_l_test2_op1 = Double.NaN; + double d_l_test2_op2 = Double.PositiveInfinity; + if (!Double.IsNaN(d_l_test2_op1 * d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 * d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 * d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 * cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 * vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 * d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 * d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 * d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 * d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 * d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 * d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 * cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 * vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 * d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 * d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 * d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") * d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") * d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") * d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") * cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") * vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") * d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") * d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") * d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 * d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 * d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 * d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 * cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 * vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 * d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 * d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 * d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 * d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 * d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 * d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 * cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 * vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 * d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 * d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 * d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] * d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] * d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] * d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] * cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] * vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] * d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] * d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] * d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] * d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] * d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] * d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] * cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] * vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] * d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] * d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] * d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] * d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 64 failed"); + passed = false; + } + } + + { + double d_l_test3_op1 = Double.NaN; + double d_l_test3_op2 = 0; + if (!Double.IsNaN(d_l_test3_op1 * d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 * d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 * d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 * cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 * vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 * d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 * d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 * d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 * d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 * d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 * d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 * cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 * vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 * d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 * d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 * d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") * d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") * d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") * d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") * cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") * vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") * d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") * d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") * d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 * d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 * d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 * d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 * cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 * vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 * d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 * d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 * d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 * d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 * d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 * d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 * cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 * vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 * d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 * d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 * d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] * d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] * d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] * d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] * cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] * vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] * d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] * d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] * d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] * d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] * d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] * d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] * cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] * vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] * d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] * d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] * d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] * d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 64 failed"); + passed = false; + } + } + + if (!passed) + { + Console.WriteLine("FAILED"); + return 1; + } + else + { + Console.WriteLine("PASSED"); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/r8NaNrem.cs b/tests/src/JIT/Methodical/NaN/r8NaNrem.cs new file mode 100644 index 0000000..ad43b18 --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/r8NaNrem.cs @@ -0,0 +1,1107 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +class r8NaNrem +{ + + //user-defined class that overloads operator % + public class numHolder + { + double d_num; + public numHolder(double d_num) + { + this.d_num = Convert.ToDouble(d_num); + } + + public static double operator %(numHolder a, double b) + { + return a.d_num % b; + } + + public static double operator %(numHolder a, numHolder b) + { + return a.d_num % b.d_num; + } + + } + + static double d_s_test1_op1 = 0.0F; + static double d_s_test1_op2 = Double.NaN; + static float d_s_test2_op1 = 0.0F; + static float d_s_test2_op2 = 0.0F; + static double d_s_test3_op1 = Double.NegativeInfinity; + static double d_s_test3_op2 = 2.1234567890987654321; + + public static double d_test1_f(String s) + { + if (s == "test1_op1") + return 0.0F; + else + return Double.NaN; + } + + public static float d_test2_f(String s) + { + if (s == "test2_op1") + return 0.0F; + else + return 0.0F; + } + + public static double d_test3_f(String s) + { + if (s == "test3_op1") + return Double.NegativeInfinity; + else + return 2.1234567890987654321; + } + + class CL + { + public double d_cl_test1_op1 = 0.0F; + public double d_cl_test1_op2 = Double.NaN; + public float d_cl_test2_op1 = 0.0F; + public float d_cl_test2_op2 = 0.0F; + public double d_cl_test3_op1 = Double.NegativeInfinity; + public double d_cl_test3_op2 = 2.1234567890987654321; + } + + struct VT + { + public double d_vt_test1_op1; + public double d_vt_test1_op2; + public float d_vt_test2_op1; + public float d_vt_test2_op2; + public double d_vt_test3_op1; + public double d_vt_test3_op2; + } + + public static int Main() + { + bool passed = true; + //initialize class + CL cl1 = new CL(); + //initialize struct + VT vt1; + vt1.d_vt_test1_op1 = 0.0F; + vt1.d_vt_test1_op2 = Double.NaN; + vt1.d_vt_test2_op1 = 0.0F; + vt1.d_vt_test2_op2 = 0.0F; + vt1.d_vt_test3_op1 = Double.NegativeInfinity; + vt1.d_vt_test3_op2 = 2.1234567890987654321; + + double[] d_arr1d_test1_op1 = { 0, 0.0F }; + double[,] d_arr2d_test1_op1 = { { 0, 0.0F }, { 1, 1 } }; + double[, ,] d_arr3d_test1_op1 = { { { 0, 0.0F }, { 1, 1 } } }; + + double[] d_arr1d_test1_op2 = { Double.NaN, 0, 1 }; + double[,] d_arr2d_test1_op2 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test1_op2 = { { { 0, Double.NaN }, { 1, 1 } } }; + + float[] d_arr1d_test2_op1 = { 0, 0.0F }; + float[,] d_arr2d_test2_op1 = { { 0, 0.0F }, { 1, 1 } }; + float[, ,] d_arr3d_test2_op1 = { { { 0, 0.0F }, { 1, 1 } } }; + + float[] d_arr1d_test2_op2 = { 0.0F, 0, 1 }; + float[,] d_arr2d_test2_op2 = { { 0, 0.0F }, { 1, 1 } }; + float[, ,] d_arr3d_test2_op2 = { { { 0, 0.0F }, { 1, 1 } } }; + + double[] d_arr1d_test3_op1 = { 0, Double.NegativeInfinity }; + double[,] d_arr2d_test3_op1 = { { 0, Double.NegativeInfinity }, { 1, 1 } }; + double[, ,] d_arr3d_test3_op1 = { { { 0, Double.NegativeInfinity }, { 1, 1 } } }; + + double[] d_arr1d_test3_op2 = { 2.1234567890987654321, 0, 1 }; + double[,] d_arr2d_test3_op2 = { { 0, 2.1234567890987654321 }, { 1, 1 } }; + double[, ,] d_arr3d_test3_op2 = { { { 0, 2.1234567890987654321 }, { 1, 1 } } }; + + int[,] index = { { 0, 0 }, { 1, 1 } }; + + { + double d_l_test1_op1 = 0.0F; + double d_l_test1_op2 = Double.NaN; + if (!Double.IsNaN(d_l_test1_op1 % d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 % d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 % d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 % cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 % vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 % d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 % d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 % d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 % d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 % d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 % d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 % cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 % vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 % d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 % d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 % d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") % d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") % d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") % d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") % cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") % vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") % d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") % d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") % d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 % d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 % d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 % d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 % cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 % vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 % d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 % d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 % d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 % d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 % d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 % d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 % cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 % vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 % d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 % d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 % d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] % d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] % d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] % d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] % cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] % vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] % d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] % d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] % d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] % d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] % d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] % d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] % cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] % vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] % d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] % d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] % d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] % d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 64 failed"); + passed = false; + } + } + + { + float d_l_test2_op1 = 0.0F; + float d_l_test2_op2 = 0.0F; + if (!Double.IsNaN(d_l_test2_op1 % d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 % d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 % d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 % cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 % vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 % d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 % d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 % d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 % d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 % d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 % d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 % cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 % vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 % d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 % d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 % d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") % d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") % d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") % d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") % cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") % vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") % d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") % d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") % d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 % d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 % d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 % d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 % cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 % vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 % d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 % d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 % d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 % d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 % d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 % d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 % cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 % vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 % d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 % d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 % d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] % d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] % d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] % d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] % cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] % vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] % d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] % d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] % d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] % d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] % d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] % d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] % cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] % vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] % d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] % d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] % d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] % d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 64 failed"); + passed = false; + } + } + + { + double d_l_test3_op1 = Double.NegativeInfinity; + double d_l_test3_op2 = 2.1234567890987654321; + if (!Double.IsNaN(d_l_test3_op1 % d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 % d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 % d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 % cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 % vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 % d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 % d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 % d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 % d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 % d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 % d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 % cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 % vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 % d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 % d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 % d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") % d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") % d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") % d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") % cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") % vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") % d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") % d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") % d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 % d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 % d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 % d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 % cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 % vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 % d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 % d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 % d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 % d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 % d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 % d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 % cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 % vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 % d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 % d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 % d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] % d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] % d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] % d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] % cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] % vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] % d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] % d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] % d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] % d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] % d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] % d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] % cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] % vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] % d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] % d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] % d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] % d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 64 failed"); + passed = false; + } + } + + if (!passed) + { + Console.WriteLine("FAILED"); + return 1; + } + else + { + Console.WriteLine("PASSED"); + return 100; + } + } +} diff --git a/tests/src/JIT/Methodical/NaN/r8NaNsub.cs b/tests/src/JIT/Methodical/NaN/r8NaNsub.cs new file mode 100644 index 0000000..4ccb3ac --- /dev/null +++ b/tests/src/JIT/Methodical/NaN/r8NaNsub.cs @@ -0,0 +1,1107 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +using System; +class r8NaNsub +{ + + //user-defined class that overloads operator - + public class numHolder + { + double d_num; + public numHolder(double d_num) + { + this.d_num = Convert.ToSingle(d_num); + } + + public static double operator -(numHolder a, double b) + { + return a.d_num - b; + } + + public static double operator -(numHolder a, numHolder b) + { + return a.d_num - b.d_num; + } + + } + + static double d_s_test1_op1 = Double.NaN; + static double d_s_test1_op2 = 0; + static double d_s_test2_op1 = Double.NaN; + static double d_s_test2_op2 = Double.NegativeInfinity; + static double d_s_test3_op1 = Double.PositiveInfinity; + static double d_s_test3_op2 = Double.PositiveInfinity; + + public static double d_test1_f(String s) + { + if (s == "test1_op1") + return Double.NaN; + else + return 0; + } + + public static double d_test2_f(String s) + { + if (s == "test2_op1") + return Double.NaN; + else + return Double.NegativeInfinity; + } + + public static double d_test3_f(String s) + { + if (s == "test3_op1") + return Double.PositiveInfinity; + else + return Double.PositiveInfinity; + } + + class CL + { + public double d_cl_test1_op1 = Double.NaN; + public double d_cl_test1_op2 = 0; + public double d_cl_test2_op1 = Double.NaN; + public double d_cl_test2_op2 = Double.NegativeInfinity; + public double d_cl_test3_op1 = Double.PositiveInfinity; + public double d_cl_test3_op2 = Double.PositiveInfinity; + } + + struct VT + { + public double d_vt_test1_op1; + public double d_vt_test1_op2; + public double d_vt_test2_op1; + public double d_vt_test2_op2; + public double d_vt_test3_op1; + public double d_vt_test3_op2; + } + public static int Main() + { + bool passed = true; + //initialize class + CL cl1 = new CL(); + //initialize struct + VT vt1; + vt1.d_vt_test1_op1 = Double.NaN; + vt1.d_vt_test1_op2 = 0; + vt1.d_vt_test2_op1 = Double.NaN; + vt1.d_vt_test2_op2 = Double.NegativeInfinity; + vt1.d_vt_test3_op1 = Double.PositiveInfinity; + vt1.d_vt_test3_op2 = Double.PositiveInfinity; + + double[] d_arr1d_test1_op1 = { 0, Double.NaN }; + double[,] d_arr2d_test1_op1 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test1_op1 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test1_op2 = { 0, 0, 1 }; + double[,] d_arr2d_test1_op2 = { { 0, 0 }, { 1, 1 } }; + double[, ,] d_arr3d_test1_op2 = { { { 0, 0 }, { 1, 1 } } }; + + double[] d_arr1d_test2_op1 = { 0, Double.NaN }; + double[,] d_arr2d_test2_op1 = { { 0, Double.NaN }, { 1, 1 } }; + double[, ,] d_arr3d_test2_op1 = { { { 0, Double.NaN }, { 1, 1 } } }; + + double[] d_arr1d_test2_op2 = { Double.NegativeInfinity, 0, 1 }; + double[,] d_arr2d_test2_op2 = { { 0, Double.NegativeInfinity }, { 1, 1 } }; + double[, ,] d_arr3d_test2_op2 = { { { 0, Double.NegativeInfinity }, { 1, 1 } } }; + + double[] d_arr1d_test3_op1 = { 0, Double.PositiveInfinity }; + double[,] d_arr2d_test3_op1 = { { 0, Double.PositiveInfinity }, { 1, 1 } }; + double[, ,] d_arr3d_test3_op1 = { { { 0, Double.PositiveInfinity }, { 1, 1 } } }; + + double[] d_arr1d_test3_op2 = { Double.PositiveInfinity, 0, 1 }; + double[,] d_arr2d_test3_op2 = { { 0, Double.PositiveInfinity }, { 1, 1 } }; + double[, ,] d_arr3d_test3_op2 = { { { 0, Double.PositiveInfinity }, { 1, 1 } } }; + + int[,] index = { { 0, 0 }, { 1, 1 } }; + + { + double d_l_test1_op1 = Double.NaN; + double d_l_test1_op2 = 0; + if (!Double.IsNaN(d_l_test1_op1 - d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 - d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 - d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 - cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 - vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 - d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 - d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test1_op1 - d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 - d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 - d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 - d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 - cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 - vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 - d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 - d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test1_op1 - d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") - d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") - d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") - d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") - cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") - vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") - d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") - d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test1_f("test1_op1") - d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 - d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 - d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 - d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 - cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 - vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 - d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 - d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test1_op1 - d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 - d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 - d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 - d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 - cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 - vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 - d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 - d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test1_op1 - d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] - d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] - d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] - d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] - cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] - vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] - d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] - d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test1_op1[1] - d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] - d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] - d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] - d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] - cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] - vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] - d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] - d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test1_op1[index[0, 1], index[1, 0]] - d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - d_l_test1_op2)) + { + Console.WriteLine("Test1_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - d_s_test1_op2)) + { + Console.WriteLine("Test1_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - d_test1_f("test1_op2"))) + { + Console.WriteLine("Test1_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - cl1.d_cl_test1_op2)) + { + Console.WriteLine("Test1_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - vt1.d_vt_test1_op2)) + { + Console.WriteLine("Test1_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - d_arr1d_test1_op2[0])) + { + Console.WriteLine("Test1_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - d_arr2d_test1_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test1_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test1_op1[index[0, 0], 0, index[1, 1]] - d_arr3d_test1_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test1_testcase 64 failed"); + passed = false; + } + } + + { + double d_l_test2_op1 = Double.NaN; + double d_l_test2_op2 = Double.NegativeInfinity; + if (!Double.IsNaN(d_l_test2_op1 - d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 - d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 - d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 - cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 - vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 - d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 - d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test2_op1 - d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 - d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 - d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 - d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 - cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 - vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 - d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 - d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test2_op1 - d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") - d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") - d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") - d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") - cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") - vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") - d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") - d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test2_f("test2_op1") - d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 - d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 - d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 - d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 - cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 - vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 - d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 - d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test2_op1 - d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 - d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 - d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 - d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 - cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 - vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 - d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 - d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test2_op1 - d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] - d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] - d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] - d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] - cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] - vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] - d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] - d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test2_op1[1] - d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] - d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] - d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] - d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] - cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] - vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] - d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] - d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test2_op1[index[0, 1], index[1, 0]] - d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] - d_l_test2_op2)) + { + Console.WriteLine("Test2_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] - d_s_test2_op2)) + { + Console.WriteLine("Test2_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] - d_test2_f("test2_op2"))) + { + Console.WriteLine("Test2_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] - cl1.d_cl_test2_op2)) + { + Console.WriteLine("Test2_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] - vt1.d_vt_test2_op2)) + { + Console.WriteLine("Test2_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] - d_arr1d_test2_op2[0])) + { + Console.WriteLine("Test2_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] - d_arr2d_test2_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test2_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test2_op1[index[0, 0], 0, index[1, 1]] - d_arr3d_test2_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test2_testcase 64 failed"); + passed = false; + } + } + + { + double d_l_test3_op1 = Double.PositiveInfinity; + double d_l_test3_op2 = Double.PositiveInfinity; + if (!Double.IsNaN(d_l_test3_op1 - d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 1 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 - d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 2 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 - d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 3 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 - cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 4 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 - vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 5 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 - d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 6 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 - d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 7 failed"); + passed = false; + } + if (!Double.IsNaN(d_l_test3_op1 - d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 8 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 - d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 9 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 - d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 10 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 - d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 11 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 - cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 12 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 - vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 13 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 - d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 14 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 - d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 15 failed"); + passed = false; + } + if (!Double.IsNaN(d_s_test3_op1 - d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 16 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") - d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 17 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") - d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 18 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") - d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 19 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") - cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 20 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") - vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 21 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") - d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 22 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") - d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 23 failed"); + passed = false; + } + if (!Double.IsNaN(d_test3_f("test3_op1") - d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 24 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 - d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 25 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 - d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 26 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 - d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 27 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 - cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 28 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 - vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 29 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 - d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 30 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 - d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 31 failed"); + passed = false; + } + if (!Double.IsNaN(cl1.d_cl_test3_op1 - d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 32 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 - d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 33 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 - d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 34 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 - d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 35 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 - cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 36 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 - vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 37 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 - d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 38 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 - d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 39 failed"); + passed = false; + } + if (!Double.IsNaN(vt1.d_vt_test3_op1 - d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 40 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] - d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 41 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] - d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 42 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] - d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 43 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] - cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 44 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] - vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 45 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] - d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 46 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] - d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 47 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr1d_test3_op1[1] - d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 48 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] - d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 49 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] - d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 50 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] - d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 51 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] - cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 52 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] - vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 53 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] - d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 54 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] - d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 55 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr2d_test3_op1[index[0, 1], index[1, 0]] - d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 56 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - d_l_test3_op2)) + { + Console.WriteLine("Test3_testcase 57 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - d_s_test3_op2)) + { + Console.WriteLine("Test3_testcase 58 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - d_test3_f("test3_op2"))) + { + Console.WriteLine("Test3_testcase 59 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - cl1.d_cl_test3_op2)) + { + Console.WriteLine("Test3_testcase 60 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - vt1.d_vt_test3_op2)) + { + Console.WriteLine("Test3_testcase 61 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - d_arr1d_test3_op2[0])) + { + Console.WriteLine("Test3_testcase 62 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - d_arr2d_test3_op2[index[0, 1], index[1, 0]])) + { + Console.WriteLine("Test3_testcase 63 failed"); + passed = false; + } + if (!Double.IsNaN(d_arr3d_test3_op1[index[0, 0], 0, index[1, 1]] - d_arr3d_test3_op2[index[0, 0], 0, index[1, 1]])) + { + Console.WriteLine("Test3_testcase 64 failed"); + passed = false; + } + } + + + if (!passed) + { + Console.WriteLine("FAILED"); + return 1; + } + else + { + Console.WriteLine("PASSED"); + return 100; + } + } +} -- 2.7.4