[tests/tset_si.c] Added mpfr_get_{si,ui} tests, including flags.

git-svn-id: svn://scm.gforge.inria.fr/svn/mpfr/trunk@9649 280ebfd0-de03-0410-8827-d642c229c3f4

1 files changed, 88 insertions, 0 deletions

diff --git a/tests/tset_si.c b/tests/tset_si.c
index ce0aa405a..82065b6c7 100644
--- a/tests/tset_si.c
+++ b/tests/tset_si.c
@@ -193,6 +193,92 @@ test_get_ui_smallneg (void)
   mpfr_clear (x);
 }
 
+static void get_tests (void)
+{
+  mpfr_t x, z;
+  long ts[5] = { LONG_MIN, LONG_MAX, -17, 0, 17 };
+  unsigned long tu[3] = { 0, ULONG_MAX, 17 };
+  int s, i, j, odd, ctr = 0;
+  int inex;
+  int r;
+
+  mpfr_init2 (x, sizeof (unsigned long) * CHAR_BIT + 3);
+  mpfr_init2 (z, MPFR_PREC_MIN);
+  mpfr_set_ui_2exp (z, 1, -2, MPFR_RNDN);  /* z = 1/4 */
+
+  for (s = 1; s >= 0; s--)
+    for (i = 0; i < (s ? 5 : 3); i++)
+      {
+        odd = (s ? (unsigned long) ts[i] : tu[i]) & 1;
+        inex = s ?
+          mpfr_set_si (x, ts[i], MPFR_RNDN) :
+          mpfr_set_ui (x, tu[i], MPFR_RNDN);
+        MPFR_ASSERTN (inex == 0);
+        inex = mpfr_sub_ui (x, x, 2, MPFR_RNDN);
+        MPFR_ASSERTN (inex == 0);
+        for (j = -8; j <= 8; j++)
+          {
+            ctr++;
+            /* x = t?[i] + j/4 */
+            RND_LOOP (r)
+              {
+                mpfr_flags_t ex_flags, flags;
+                int k, overflow;
+
+                k = (j + 8 +
+                     (MPFR_IS_LIKE_RNDD (r, MPFR_SIGN (x)) ? 0 :
+                      MPFR_IS_LIKE_RNDU (r, MPFR_SIGN (x)) ? 3 :
+                      2)) / 4 - 2;
+                if (r == MPFR_RNDN && ((unsigned int) j & 3) == 2 &&
+                    ((odd + k) & 1))
+                  k--;  /* even rounding */
+                overflow = (i == 0 && k < 0) || (i == 1 && k > 0);
+
+                ex_flags = overflow ? MPFR_FLAGS_ERANGE
+                  : ((unsigned int) j & 3) != 0 ? MPFR_FLAGS_INEXACT : 0;
+
+                mpfr_clear_flags ();
+
+#define GET_TESTS_TEST(TYPE,TZ,F,C,FMT)                                 \
+                do {                                                    \
+                  TYPE a, d;                                            \
+                                                                        \
+                  a = TZ[i] + (overflow ? 0 : k);                       \
+                  d = F (x, (mpfr_rnd_t) r);                            \
+                  if (__gmpfr_flags != ex_flags || a != d)              \
+                    {                                                   \
+                      flags = __gmpfr_flags;                            \
+                      printf ("Error in get_tests for " #F " on %s,\n", \
+                              mpfr_print_rnd_mode ((mpfr_rnd_t) r));    \
+                      printf ("x = t" C "[%d] + (%d/4) = ", i, j);      \
+                      mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN);       \
+                      printf ("\n--> k = %d\n", k);                     \
+                      printf ("Expected %l" FMT "\n", a);               \
+                      printf ("Got      %l" FMT "\n", d);               \
+                      printf ("Expected flags:");                       \
+                      flags_out (ex_flags);                             \
+                      printf ("Got flags:     ");                       \
+                      flags_out (flags);                                \
+                      exit (1);                                         \
+                    }                                                   \
+                } while (0)
+
+                if (s)
+                  GET_TESTS_TEST (long, ts, mpfr_get_si, "s", "d");
+                else
+                  GET_TESTS_TEST (unsigned long, tu, mpfr_get_ui, "u", "u");
+              }
+            inex = mpfr_add (x, x, z, MPFR_RNDN);
+            MPFR_ASSERTN (inex == 0);
+          }
+      }
+
+  MPFR_ASSERTN (ctr == 8*17);
+
+  mpfr_clear (x);
+  mpfr_clear (z);
+}
+
 /* FIXME: Comparing against mpfr_get_si/ui is not ideal, it'd be better to
    have all tests examine the bits in mpfr_t for what should come out.  */
 
@@ -209,6 +295,8 @@ main (int argc, char *argv[])
 
   tests_start_mpfr ();
 
+  get_tests ();
+
   mpfr_init2 (x, 100);
 
   N = (argc==1) ? 100000 : atol (argv[1]);