summaryrefslogtreecommitdiff
path: root/src/pal/tests/palsuite/c_runtime/_finite/test1/test1.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/pal/tests/palsuite/c_runtime/_finite/test1/test1.cpp')
-rw-r--r--src/pal/tests/palsuite/c_runtime/_finite/test1/test1.cpp119
1 files changed, 119 insertions, 0 deletions
diff --git a/src/pal/tests/palsuite/c_runtime/_finite/test1/test1.cpp b/src/pal/tests/palsuite/c_runtime/_finite/test1/test1.cpp
new file mode 100644
index 0000000..c815055
--- /dev/null
+++ b/src/pal/tests/palsuite/c_runtime/_finite/test1/test1.cpp
@@ -0,0 +1,119 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+/*============================================================================
+**
+** Source: test1.c
+**
+** Purpose: Checks that _finite correctly classifies all types
+** of floating point numbers (NaN, -Infinity, Infinity,
+** finite nonzero, unnormalized, 0, and -0)
+**
+**==========================================================================*/
+
+#include <palsuite.h>
+
+/*
+The IEEE double precision floating point standard looks like this:
+
+ S EEEEEEEEEEE FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+ 0 1 11 12 63
+
+S is the sign bit. The E bits are the exponent, and the 52 F bits are
+the fraction. These represent a value, V.
+
+If E=2047 and F is nonzero, then V=NaN ("Not a number")
+If E=2047 and F is zero and S is 1, then V=-Infinity
+If E=2047 and F is zero and S is 0, then V=Infinity
+If 0<E<2047 then V=(-1)^S * 2^(E-1023) * (1.F) where "1.F" is the binary
+ number created by prefixing F with a leading 1 and a binary point.
+If E=0 and F is nonzero, then V=(-1)^S * 2^(-1022) * (0.F) These are
+ "unnormalized" values.
+If E=0 and F is zero and S is 1, then V=-0
+If E=0 and F is zero and S is 0, then V=0
+
+*/
+
+#define TO_DOUBLE(x) (*((double*)((void*)&x)))
+
+int __cdecl main(int argc, char **argv)
+{
+ /*non-finite numbers*/
+ UINT64 lsnan = UI64(0xffffffffffffffff);
+ UINT64 lqnan = UI64(0x7fffffffffffffff);
+ UINT64 lneginf = UI64(0xfff0000000000000);
+ UINT64 lposinf = UI64(0x7ff0000000000000);
+
+ double snan = TO_DOUBLE(lsnan);
+ double qnan = TO_DOUBLE(lqnan);
+ double neginf = TO_DOUBLE(lneginf);
+ double posinf = TO_DOUBLE(lposinf);
+
+ /*finite numbers*/
+ UINT64 lnegunnormalized = UI64(0x800fffffffffffff);
+ UINT64 lposunnormalized = UI64(0x000fffffffffffff);
+ UINT64 lnegzero = UI64(0x8000000000000000);
+
+ double negunnormalized = TO_DOUBLE(lnegunnormalized);
+ double posunnormalized = TO_DOUBLE(lposunnormalized);
+ double negzero = TO_DOUBLE(lnegzero);
+
+ /*
+ * Initialize the PAL and return FAIL if this fails
+ */
+ if (PAL_Initialize(argc, argv) != 0)
+ {
+ return FAIL;
+ }
+
+ /*non-finite numbers*/
+ if (_finite(snan) || _finite(qnan))
+ {
+ Fail("_finite() found NAN to be finite.\n");
+ }
+
+ if (_finite(neginf))
+ {
+ Fail("_finite() found negative infinity to be finite.\n");
+ }
+
+ if (_finite(posinf))
+ {
+ Fail("_finite() found infinity to be finite.\n");
+ }
+
+ /*finite numbers*/
+ if (!_finite(negunnormalized))
+ {
+ Fail("_finite() found a negative unnormalized value to be infinite.\n");
+ }
+
+ if (!_finite(posunnormalized))
+ {
+ Fail("_finite() found an unnormalized value to be infinite.\n");
+ }
+
+ if (!_finite(negzero))
+ {
+ Fail("_finite() found negative zero to be infinite.\n");
+ }
+
+ if (!_finite(+0.0))
+ {
+ Fail("_finite() found zero to be infinite.\n");
+ }
+
+ if (!_finite(-123.456))
+ {
+ Fail("_finite() found %f to be infinite.\n", -123.456);
+ }
+
+ if (!_finite(+123.456))
+ {
+ Fail("_finite() found %f to be infinite.\n", +123.456);
+ }
+
+ PAL_Terminate();
+ return PASS;
+}