updated tests to correct format

Author: Sriya Pratipati

libc/fuzzing/math/CMakeLists.txt

@@ -98,15 +98,6 @@ add_libc_fuzzer(
     libc.src.math.cos
 )
 
-add_libc_fuzzer(
-  atan_fuzz
-  NEED_MPFR
-  SRCS
-    atan_fuzz.cpp
-  DEPENDS
-    libc.src.math.atan
-)
-
 add_libc_fuzzer(
   tan_fuzz
   NEED_MPFR

libc/fuzzing/math/atan_fuzz.cpp

@@ -12,27 +12,38 @@
 
 #include "src/math/log10.h"
 #include "utils/MPFRWrapper/mpfr_inc.h"
+#include <cstdint>
+#include <cstring>
+#include <iostream>
 #include <math.h>
 
-extern "C" int LLVMFuzzerTestOneInput(double x) {
-  // remove NaN and inf and values outside accepted range
-  if (isnan(x) || isinf(x) || x < 0)
-    return 0;
-  // signed zeros already tested in unit tests
-  if (signbit(x) && x == 0.0)
-    return 0;
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   mpfr_t input;
   mpfr_init2(input, 53);
-  mpfr_set_d(input, x, MPFR_RNDN);
-  int output = mpfr_log10(input, input, MPFR_RNDN);
-  mpfr_subnormalize(input, output, MPFR_RNDN);
-  double to_compare = mpfr_get_d(input, MPFR_RNDN);
+  for (size_t i = 0; i < size / sizeof(double); ++i) {
+    double x;
+    std::memcpy(&x, data, sizeof(double));
+    // remove NaN and inf and values outside accepted range
+    if (isnan(x) || isinf(x) || x < 0)
+      return 0;
+    // signed zeros already tested in unit tests
+    if (signbit(x) && x == 0.0)
+      return 0;
 
-  double result = LIBC_NAMESPACE::log10(x);
+    mpfr_set_d(input, x, MPFR_RNDN);
+    int output = mpfr_log10(input, input, MPFR_RNDN);
+    mpfr_subnormalize(input, output, MPFR_RNDN);
+    double to_compare = mpfr_get_d(input, MPFR_RNDN);
 
-  if (result != to_compare)
-    __builtin_trap();
+    double result = LIBC_NAMESPACE::log10(x);
 
+    if (result != to_compare) {
+      std::cout << std::hexfloat << "Failing input: " << x << std::endl;
+      std::cout << std::hexfloat << "Failing output: " << result << std::endl;
+      std::cout << std::hexfloat << "Expected: " << to_compare << std::endl;
+      __builtin_trap();
+    }
+  }
   mpfr_clear(input);
   return 0;
 }

libc/fuzzing/math/log10_fuzz.cpp

@@ -12,27 +12,38 @@
 
 #include "src/math/log1p.h"
 #include "utils/MPFRWrapper/mpfr_inc.h"
+#include <cstdint>
+#include <cstring>
+#include <iostream>
 #include <math.h>
 
-extern "C" int LLVMFuzzerTestOneInput(double x) {
-  // remove NaN and inf and values outside accepted range
-  if (isnan(x) || isinf(x) || x < -1)
-    return 0;
-  // signed zeros already tested in unit tests
-  if (signbit(x) && x == 0.0)
-    return 0;
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   mpfr_t input;
   mpfr_init2(input, 53);
-  mpfr_set_d(input, x, MPFR_RNDN);
-  int output = mpfr_log1p(input, input, MPFR_RNDN);
-  mpfr_subnormalize(input, output, MPFR_RNDN);
-  double to_compare = mpfr_get_d(input, MPFR_RNDN);
+  for (size_t i = 0; i < size / sizeof(double); ++i) {
+    double x;
+    std::memcpy(&x, data, sizeof(double));
+    // remove NaN and inf and values outside accepted range
+    if (isnan(x) || isinf(x) || x < -1)
+      return 0;
+    // signed zeros already tested in unit tests
+    if (signbit(x) && x == 0.0)
+      return 0;
 
-  double result = LIBC_NAMESPACE::log1p(x);
+    mpfr_set_d(input, x, MPFR_RNDN);
+    int output = mpfr_log1p(input, input, MPFR_RNDN);
+    mpfr_subnormalize(input, output, MPFR_RNDN);
+    double to_compare = mpfr_get_d(input, MPFR_RNDN);
 
-  if (result != to_compare)
-    __builtin_trap();
+    double result = LIBC_NAMESPACE::log1p(x);
 
+    if (result != to_compare) {
+      std::cout << std::hexfloat << "Failing input: " << x << std::endl;
+      std::cout << std::hexfloat << "Failing output: " << result << std::endl;
+      std::cout << std::hexfloat << "Expected: " << to_compare << std::endl;
+      __builtin_trap();
+    }
+  }
   mpfr_clear(input);
   return 0;
 }

libc/fuzzing/math/log1p_fuzz.cpp

@@ -12,27 +12,38 @@
 
 #include "src/math/log2.h"
 #include "utils/MPFRWrapper/mpfr_inc.h"
+#include <cstdint>
+#include <cstring>
+#include <iostream>
 #include <math.h>
 
-extern "C" int LLVMFuzzerTestOneInput(double x) {
-  // remove NaN and inf and values outside accepted range
-  if (isnan(x) || isinf(x) || x < 0)
-    return 0;
-  // signed zeros already tested in unit tests
-  if (signbit(x) && x == 0.0)
-    return 0;
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   mpfr_t input;
   mpfr_init2(input, 53);
-  mpfr_set_d(input, x, MPFR_RNDN);
-  int output = mpfr_log2(input, input, MPFR_RNDN);
-  mpfr_subnormalize(input, output, MPFR_RNDN);
-  double to_compare = mpfr_get_d(input, MPFR_RNDN);
+  for (size_t i = 0; i < size / sizeof(double); ++i) {
+    double x;
+    std::memcpy(&x, data, sizeof(double));
+    // remove NaN and inf and values outside accepted range
+    if (isnan(x) || isinf(x) || x < 0)
+      return 0;
+    // signed zeros already tested in unit tests
+    if (signbit(x) && x == 0.0)
+      return 0;
 
-  double result = LIBC_NAMESPACE::log2(x);
+    mpfr_set_d(input, x, MPFR_RNDN);
+    int output = mpfr_log2(input, input, MPFR_RNDN);
+    mpfr_subnormalize(input, output, MPFR_RNDN);
+    double to_compare = mpfr_get_d(input, MPFR_RNDN);
 
-  if (result != to_compare)
-    __builtin_trap();
+    double result = LIBC_NAMESPACE::log2(x);
 
+    if (result != to_compare) {
+      std::cout << std::hexfloat << "Failing input: " << x << std::endl;
+      std::cout << std::hexfloat << "Failing output: " << result << std::endl;
+      std::cout << std::hexfloat << "Expected: " << to_compare << std::endl;
+      __builtin_trap();
+    }
+  }
   mpfr_clear(input);
   return 0;
 }

libc/fuzzing/math/log2_fuzz.cpp

@@ -12,27 +12,37 @@
 
 #include "src/math/log.h"
 #include "utils/MPFRWrapper/mpfr_inc.h"
+#include <cstdint>
+#include <cstring>
+#include <iostream>
 #include <math.h>
 
-extern "C" int LLVMFuzzerTestOneInput(double x) {
-  // remove NaN and inf and values outside accepted range
-  if (isnan(x) || isinf(x) || x < 0)
-    return 0;
-  // signed zeros already tested in unit tests
-  if (signbit(x) && x == 0.0)
-    return 0;
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   mpfr_t input;
   mpfr_init2(input, 53);
-  mpfr_set_d(input, x, MPFR_RNDN);
-  int output = mpfr_log(input, input, MPFR_RNDN);
-  mpfr_subnormalize(input, output, MPFR_RNDN);
-  double to_compare = mpfr_get_d(input, MPFR_RNDN);
+  for (size_t i = 0; i < size / sizeof(double); ++i) {
+    double x;
+    std::memcpy(&x, data, sizeof(double));
+    // remove NaN and inf and values outside accepted range
+    if (isnan(x) || isinf(x) || x < 0)
+      return 0;
+    // signed zeros already tested in unit tests
+    if (signbit(x) && x == 0.0)
+      return 0;
+    mpfr_set_d(input, x, MPFR_RNDN);
+    int output = mpfr_log(input, input, MPFR_RNDN);
+    mpfr_subnormalize(input, output, MPFR_RNDN);
+    double to_compare = mpfr_get_d(input, MPFR_RNDN);
 
-  double result = LIBC_NAMESPACE::log(x);
-
-  if (result != to_compare)
-    __builtin_trap();
+    double result = LIBC_NAMESPACE::log(x);
 
+    if (result != to_compare) {
+      std::cout << std::hexfloat << "Failing input: " << x << std::endl;
+      std::cout << std::hexfloat << "Failing output: " << result << std::endl;
+      std::cout << std::hexfloat << "Expected: " << to_compare << std::endl;
+      __builtin_trap();
+    }
+  }
   mpfr_clear(input);
   return 0;
 }

libc/fuzzing/math/log_fuzz.cpp

@@ -12,27 +12,38 @@
 
 #include "src/__support/FPUtil/generic/sqrt.h"
 #include "utils/MPFRWrapper/mpfr_inc.h"
+#include <cstdint>
+#include <cstring>
+#include <iostream>
 #include <math.h>
 
-extern "C" int LLVMFuzzerTestOneInput(double x) {
-  // remove NaN and inf and values outside accepted range
-  if (isnan(x) || isinf(x) || x < 0)
-    return 0;
-  // signed zeros already tested in unit tests
-  if (signbit(x) && x == 0.0)
-    return 0;
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   mpfr_t input;
   mpfr_init2(input, 53);
-  mpfr_set_d(input, x, MPFR_RNDN);
-  int output = mpfr_sqrt(input, input, MPFR_RNDN);
-  mpfr_subnormalize(input, output, MPFR_RNDN);
-  double to_compare = mpfr_get_d(input, MPFR_RNDN);
+  for (size_t i = 0; i < size / sizeof(double); ++i) {
+    double x;
+    std::memcpy(&x, data, sizeof(double));
+    // remove NaN and inf and values outside accepted range
+    if (isnan(x) || isinf(x) || x < 0)
+      return 0;
+    // signed zeros already tested in unit tests
+    if (signbit(x) && x == 0.0)
+      return 0;
 
-  double result = LIBC_NAMESPACE::fputil::sqrt<double>(x);
+    mpfr_set_d(input, x, MPFR_RNDN);
+    int output = mpfr_sqrt(input, input, MPFR_RNDN);
+    mpfr_subnormalize(input, output, MPFR_RNDN);
+    double to_compare = mpfr_get_d(input, MPFR_RNDN);
 
-  if (result != to_compare)
-    __builtin_trap();
+    double result = LIBC_NAMESPACE::fputil::sqrt<double>(x);
 
+    if (result != to_compare) {
+      std::cout << std::hexfloat << "Failing input: " << x << std::endl;
+      std::cout << std::hexfloat << "Failing output: " << result << std::endl;
+      std::cout << std::hexfloat << "Expected: " << to_compare << std::endl;
+      __builtin_trap();
+    }
+  }
   mpfr_clear(input);
   return 0;
 }