t-expr.c

a very popular packet of cryptography tools,it encloses the most common used algorithm and protocols

};

struct datalist_t  list_q[] = {
  DATALIST (data_q),
  DATALIST (data_zq),
  DATALIST (data_zqfr),
};

struct datalist_t  list_f[] = {
  DATALIST (data_zfr),
  DATALIST (data_zqfr),
  DATALIST (data_fr),
  DATALIST (data_f),
};

struct datalist_t  list_r[] = {
  DATALIST (data_zfr),
  DATALIST (data_zqfr),
  DATALIST (data_zr),
  DATALIST (data_fr),
  DATALIST (data_r),
};


void
check_z (void)
{
  const struct data_t  *data;
  mpz_t  a, b, got, want;
  int    l, i, ret;

  mpz_init (got);
  mpz_init (want);
  mpz_init_set_ui (a, 55);
  mpz_init_set_ui (b, 99);

  for (l = 0; l < numberof (list_z); l++)
    {
      data = list_z[l].data;

      for (i = 0; i < list_z[l].num; i++)
        {
          if (option_trace)
            printf ("mpz_expr \"%s\"\n", data[i].expr);

          ret = mpz_expr (got, data[i].base, data[i].expr, a, b, NULL);

          if (data[i].want == NULL)
            {
              /* expect to fail */
              if (ret == MPEXPR_RESULT_OK)
                {
                  printf ("mpz_expr wrong return value, got %d, expected failure\n", ret);
                  goto error;
                }
            }
          else
            {
              if (mpz_set_str (want, data[i].want, 0) != 0)
                {
                  printf ("Cannot parse wanted value string\n");
                  goto error;
                }
              if (ret != MPEXPR_RESULT_OK)
                {
                  printf ("mpz_expr failed unexpectedly\n");
                  printf ("   return value %d\n", ret);
                  goto error;
                }
              if (mpz_cmp (got, want) != 0)
                {
                  printf ("mpz_expr wrong result\n");
                  printf ("   got  "); mpz_out_str (stdout, 10, got);
                  printf ("\n");
                  printf ("   want "); mpz_out_str (stdout, 10, want);
                  printf ("\n");
                  goto error;
                }
            }
        }
    }
  mpz_clear (a);
  mpz_clear (b);
  mpz_clear (got);
  mpz_clear (want);
  return;

 error:
  printf ("   base %d\n", data[i].base);
  printf ("   expr \"%s\"\n", data[i].expr);
  if (data[i].want != NULL)
    printf ("   want \"%s\"\n", data[i].want);
  abort ();
}

void
check_q (void)
{
  const struct data_t  *data;
  mpq_t  a, b, got, want;
  int    l, i, ret;

  mpq_init (got);
  mpq_init (want);
  mpq_init (a);
  mpq_init (b);

  mpq_set_ui (a, 55, 1);
  mpq_set_ui (b, 99, 1);

  for (l = 0; l < numberof (list_q); l++)
    {
      data = list_q[l].data;

      for (i = 0; i < list_q[l].num; i++)
        {
          if (option_trace)
            printf ("mpq_expr \"%s\"\n", data[i].expr);

          ret = mpq_expr (got, data[i].base, data[i].expr, a, b, NULL);

          if (data[i].want == NULL)
            {
              /* expect to fail */
              if (ret == MPEXPR_RESULT_OK)
                {
                  printf ("mpq_expr wrong return value, got %d, expected failure\n", ret);
                  goto error;
                }
            }
          else
            {
              if (mpz_set_str (mpq_numref(want), data[i].want, 0) != 0)
                {
                  printf ("Cannot parse wanted value string\n");
                  goto error;
                }
              mpz_set_ui (mpq_denref(want), 1);

              if (ret != MPEXPR_RESULT_OK)
                {
                  printf ("mpq_expr failed unexpectedly\n");
                  printf ("   return value %d\n", ret);
                  goto error;
                }
              if (mpq_cmp (got, want) != 0)
                {
                  printf ("mpq_expr wrong result\n");
                  printf ("   got  "); mpq_out_str (stdout, 10, got);
                  printf ("\n");
                  printf ("   want "); mpq_out_str (stdout, 10, want);
                  printf ("\n");
                  goto error;
                }
            }
        }
    }
  mpq_clear (a);
  mpq_clear (b);
  mpq_clear (got);
  mpq_clear (want);
  return;

 error:
  printf ("   base %d\n", data[i].base);
  printf ("   expr \"%s\"\n", data[i].expr);
  if (data[i].want != NULL)
    printf ("   want \"%s\"\n", data[i].want);
  abort ();
}

void
check_f (void)
{
  const struct data_t  *data;
  mpf_t  a, b, got, want;
  int    l, i, ret;

  mpf_set_default_prec (200L);

  mpf_init (got);
  mpf_init (want);
  mpf_init_set_ui (a, 55);
  mpf_init_set_ui (b, 99);

  for (l = 0; l < numberof (list_f); l++)
    {
      data = list_f[l].data;

      for (i = 0; i < list_f[l].num; i++)
        {
          if (option_trace)
            printf ("mpf_expr \"%s\"\n", data[i].expr);

          ret = mpf_expr (got, data[i].base, data[i].expr, a, b, NULL);

          if (data[i].want == NULL)
            {
              /* expect to fail */
              if (ret == MPEXPR_RESULT_OK)
                {
                  printf ("mpf_expr wrong return value, got %d, expected failure\n", ret);
                  goto error;
                }
            }
          else
            {
              if (mpf_set_str (want, data[i].want, 0) != 0)
                {
                  printf ("Cannot parse wanted value string\n");
                  goto error;
                }

              if (ret != MPEXPR_RESULT_OK)
                {
                  printf ("mpf_expr failed unexpectedly\n");
                  printf ("   return value %d\n", ret);
                  goto error;
                }
              if (mpf_cmp (got, want) != 0)
                {
                  printf ("mpf_expr wrong result\n");
                  printf ("   got  "); mpf_out_str (stdout, 10, 20, got);
                  printf ("\n");
                  printf ("   want "); mpf_out_str (stdout, 10, 20, want);
                  printf ("\n");
                  goto error;
                }
            }
        }
    }
  mpf_clear (a);
  mpf_clear (b);
  mpf_clear (got);
  mpf_clear (want);
  return;

 error:
  printf ("   base %d\n", data[i].base);
  printf ("   expr \"%s\"\n", data[i].expr);
  if (data[i].want != NULL)
    printf ("   want \"%s\"\n", data[i].want);
  abort ();
}

#if HAVE_MPFR
void
check_r (void)
{
  const struct data_t  *data;
  mpfr_t  a, b, got, want, diff, tolerance;
  int     l, i, ret;

  mpfr_set_default_prec (300L);

  mpfr_init (got);
  mpfr_init (want);
  mpfr_init (diff);
  mpfr_init (tolerance);
  mpfr_init (a);
  mpfr_init (b);
  mpfr_set_ui (a, 55L, GMP_RNDZ);
  mpfr_set_ui (b, 99L, GMP_RNDZ);

  mpfr_set_ui (tolerance, 1L, GMP_RNDZ);
  mpfr_div_2exp (tolerance, tolerance, 190L, GMP_RNDZ);

  for (l = 0; l < numberof (list_r); l++)
    {
      data = list_r[l].data;

      for (i = 0; i < list_r[l].num; i++)
        {
          if (option_trace)
            printf ("mpfr_expr \"%s\"\n", data[i].expr);

          ret = mpfr_expr (got, data[i].base, data[i].expr, a, b, NULL);

          if (data[i].want == NULL)
            {
              /* expect to fail */
              if (ret == MPEXPR_RESULT_OK)
                {
                  printf ("mpfr_expr wrong return value, got %d, expected failure\n", ret);
                  goto error;
                }
            }
          else
            {
              if (ret != MPEXPR_RESULT_OK)
                {
                  printf ("mpfr_expr failed unexpectedly\n");
                  printf ("   return value %d\n", ret);
                  goto error;
                }

              /* empty string means don't check the result value as such */
              if (data[i].want[0] != '\0')
                {
                  const char  *want_str = data[i].want;
                  int         approx = (*want_str == '~');
                  want_str += approx;
                  if (mpfr_set_str (want, want_str, 10, GMP_RNDZ) != 0)
                    {
                      printf ("Cannot parse wanted value string\n");
                      printf ("    \"%s\"\n", want_str);
                      goto error;
                    }
                  if (approx)
                    {
                      mpfr_sub (diff, got, want, GMP_RNDZ);
                      mpfr_abs (diff, diff, GMP_RNDZ);
                      if (mpfr_cmp (diff, tolerance) >= 0)
                        {
                          printf ("mpfr_expr result outside tolerance\n");
                          printf ("   \"%s\"\n", data[i].expr);
                          printf ("   got  ");
                          mpfr_out_str (stdout, 10, 0, got, GMP_RNDZ);
                          printf ("\n");
                          printf ("   want ");
                          mpfr_out_str (stdout, 10, 0, want, GMP_RNDZ);
                          printf ("\n");
                          printf ("   diff ");
                          mpfr_out_str (stdout, 10, 0, diff, GMP_RNDZ);
                          printf ("\n");
                          goto error;
                        }
                    }
                  else
                    {
                      if (mpfr_cmp (got, want) != 0)
                        {
                          printf ("mpfr_expr wrong result\n");
                          printf ("   \"%s\"\n", data[i].expr);
                          printf ("   got  ");
                          mpfr_out_str (stdout, 10, 20, got, GMP_RNDZ);
                          printf ("\n");
                          printf ("   want ");
                          mpfr_out_str (stdout, 10, 20, want, GMP_RNDZ);
                          printf ("\n");
                          goto error;
                        }
                    }
                }
            }
        }
    }
  mpfr_clear (a);
  mpfr_clear (b);
  mpfr_clear (got);
  mpfr_clear (want);
  mpfr_clear (diff);
  mpfr_clear (tolerance);

  if (__mpfr_const_pi_prec != 0)
    {
      mpfr_clear (__mpfr_const_pi);
      __mpfr_const_pi_prec = 0;
    }
  if (__mpfr_const_log2_prec != 0)
    {
      mpfr_clear (__mpfr_const_log2);
      __mpfr_const_log2_prec = 0;
    }

  return;

 error:
  printf ("   base %d\n", data[i].base);
  printf ("   expr \"%s\"\n", data[i].expr);
  if (data[i].want != NULL)
    printf ("   want \"%s\"\n", data[i].want);
  abort ();
}
#endif


int
main (int argc, char *argv[])
{
  tests_start ();

  if (argc >= 2)
    option_trace = 1;

  check_z ();
  check_q ();
  check_f ();
#if HAVE_MPFR
  check_r ();
#endif

  tests_end ();
  exit (0);
}