From: Eric Blake <eblake@redhat.com>
To: qemu-devel@nongnu.org
Cc: hreitz@redhat.com
Subject: [PATCH 04/11] test-cutils: Add coverage of qemu_strtod
Date: Mon, 8 May 2023 15:03:36 -0500 [thread overview]
Message-ID: <20230508200343.791450-5-eblake@redhat.com> (raw)
In-Reply-To: <20230508200343.791450-1-eblake@redhat.com>
Plenty more corner cases of strtod proper, but this covers the bulk of
what our wrappers do. In particular, it demonstrates the difference on
when *value is left uninitialized, which an upcoming patch will
normalize.
Signed-off-by: Eric Blake <eblake@redhat.com>
---
tests/unit/test-cutils.c | 435 +++++++++++++++++++++++++++++++++++++++
1 file changed, 435 insertions(+)
diff --git a/tests/unit/test-cutils.c b/tests/unit/test-cutils.c
index 1eeaf21ae22..4c096c6fc70 100644
--- a/tests/unit/test-cutils.c
+++ b/tests/unit/test-cutils.c
@@ -25,6 +25,8 @@
* THE SOFTWARE.
*/
+#include <math.h>
+
#include "qemu/osdep.h"
#include "qemu/cutils.h"
#include "qemu/units.h"
@@ -2044,6 +2046,414 @@ static void test_qemu_strtou64_full_max(void)
g_free(str);
}
+static void test_qemu_strtod_simple(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* no radix or exponent */
+ str = "1";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 1.0);
+ g_assert_true(endptr == str + 1);
+
+ /* leading space and sign */
+ str = " -0.0";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, -0.0);
+ g_assert_true(signbit(res));
+ g_assert_true(endptr == str + 5);
+
+ /* fraction only */
+ str = "+.5";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 0.5);
+ g_assert_true(endptr == str + 3);
+
+ /* exponent */
+ str = "1.e+1";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 10.0);
+ g_assert_true(endptr == str + 5);
+}
+
+static void test_qemu_strtod_einval(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* empty */
+ str = "";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 0.0);
+ g_assert_true(endptr == str);
+
+ /* NULL */
+ str = NULL;
+ endptr = "random";
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_null(endptr);
+
+ /* not recognizable */
+ str = " junk";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 0.0);
+ g_assert_true(endptr == str);
+}
+
+static void test_qemu_strtod_erange(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* overflow */
+ str = "9e999";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, ==, HUGE_VAL);
+ g_assert_true(endptr == str + 5);
+
+ str = "-9e+999";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, ==, -HUGE_VAL);
+ g_assert_true(endptr == str + 7);
+
+ /* underflow */
+ str = "-9e-999";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, >=, -DBL_MIN);
+ g_assert_cmpfloat(res, <=, -0.0);
+ g_assert_true(signbit(res));
+ g_assert_true(endptr == str + 7);
+}
+
+static void test_qemu_strtod_nonfinite(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* infinity */
+ str = "inf";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_true(isinf(res));
+ g_assert_false(signbit(res));
+ g_assert_true(endptr == str + 3);
+
+ str = "-infinity";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_true(isinf(res));
+ g_assert_true(signbit(res));
+ g_assert_true(endptr == str + 9);
+
+ /* not a number */
+ str = " NaN";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_true(isnan(res));
+ g_assert_true(endptr == str + 4);
+}
+
+static void test_qemu_strtod_trailing(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* trailing whitespace */
+ str = "1. ";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 1.0);
+ g_assert_true(endptr == str + 2);
+
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 1.0);
+
+ /* trailing e is not an exponent */
+ str = ".5e";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 0.5);
+ g_assert_true(endptr == str + 2);
+
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 0.5);
+
+ /* trailing ( not part of long NaN */
+ str = "nan(";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_true(isnan(res));
+ g_assert_true(endptr == str + 3);
+
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_true(isnan(res));
+}
+
+static void test_qemu_strtod_finite_simple(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* no radix or exponent */
+ str = "1";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 1.0);
+ g_assert_true(endptr == str + 1);
+
+ /* leading space and sign */
+ str = " -0.0";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, -0.0);
+ g_assert_true(signbit(res));
+ g_assert_true(endptr == str + 5);
+
+ /* fraction only */
+ str = "+.5";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 0.5);
+ g_assert_true(endptr == str + 3);
+
+ /* exponent */
+ str = "1.e+1";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 10.0);
+ g_assert_true(endptr == str + 5);
+}
+
+static void test_qemu_strtod_finite_einval(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* empty */
+ str = "";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+
+ /* NULL */
+ str = NULL;
+ endptr = "random";
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_null(endptr);
+
+ /* not recognizable */
+ str = " junk";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+}
+
+static void test_qemu_strtod_finite_erange(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* overflow */
+ str = "9e999";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, ==, HUGE_VAL);
+ g_assert_true(endptr == str + 5);
+
+ str = "-9e+999";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, ==, -HUGE_VAL);
+ g_assert_true(endptr == str + 7);
+
+ /* underflow */
+ str = "-9e-999";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -ERANGE);
+ g_assert_cmpfloat(res, >=, -DBL_MIN);
+ g_assert_cmpfloat(res, <=, -0.0);
+ g_assert_true(signbit(res));
+ g_assert_true(endptr == str + 7);
+}
+
+static void test_qemu_strtod_finite_nonfinite(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* infinity */
+ str = "inf";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+
+ str = "-infinity";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+
+ /* not a number */
+ str = " NaN";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+}
+
+static void test_qemu_strtod_finite_trailing(void)
+{
+ const char *str;
+ const char *endptr;
+ int err;
+ double res;
+
+ /* trailing whitespace */
+ str = "1. ";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 1.0);
+ g_assert_true(endptr == str + 2);
+
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+
+ /* trailing e is not an exponent */
+ str = ".5e";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, 0);
+ g_assert_cmpfloat(res, ==, 0.5);
+ g_assert_true(endptr == str + 2);
+
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+
+ /* trailing ( not part of long NaN */
+ str = "nan(";
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, &endptr, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+ g_assert_true(endptr == str);
+
+ endptr = NULL;
+ res = 999;
+ err = qemu_strtod_finite(str, NULL, &res);
+ g_assert_cmpint(err, ==, -EINVAL);
+ g_assert_cmpfloat(res, ==, 999.0);
+}
+
static void test_qemu_strtosz_simple(void)
{
const char *str;
@@ -2833,6 +3243,31 @@ int main(int argc, char **argv)
g_test_add_func("/cutils/qemu_strtou64_full/max",
test_qemu_strtou64_full_max);
+ /* qemu_strtod() tests */
+ g_test_add_func("/cutils/qemu_strtod/simple",
+ test_qemu_strtod_simple);
+ g_test_add_func("/cutils/qemu_strtod/einval",
+ test_qemu_strtod_einval);
+ g_test_add_func("/cutils/qemu_strtod/erange",
+ test_qemu_strtod_erange);
+ g_test_add_func("/cutils/qemu_strtod/nonfinite",
+ test_qemu_strtod_nonfinite);
+ g_test_add_func("/cutils/qemu_strtod/trailing",
+ test_qemu_strtod_trailing);
+
+ /* qemu_strtod_finite() tests */
+ g_test_add_func("/cutils/qemu_strtod_finite/simple",
+ test_qemu_strtod_finite_simple);
+ g_test_add_func("/cutils/qemu_strtod_finite/einval",
+ test_qemu_strtod_finite_einval);
+ g_test_add_func("/cutils/qemu_strtod_finite/erange",
+ test_qemu_strtod_finite_erange);
+ g_test_add_func("/cutils/qemu_strtod_finite/nonfinite",
+ test_qemu_strtod_finite_nonfinite);
+ g_test_add_func("/cutils/qemu_strtod_finite/trailing",
+ test_qemu_strtod_finite_trailing);
+
+ /* qemu_strtosz() tests */
g_test_add_func("/cutils/strtosz/simple",
test_qemu_strtosz_simple);
g_test_add_func("/cutils/strtosz/hex",
--
2.40.1
next prev parent reply other threads:[~2023-05-08 20:06 UTC|newest]
Thread overview: 25+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-05-08 20:03 [PATCH 00/11] Fix qemu_strtosz() read-out-of-bounds Eric Blake
2023-05-08 20:03 ` [PATCH 01/11] test-cutils: Avoid g_assert in unit tests Eric Blake
2023-05-08 20:03 ` [PATCH 02/11] test-cutils: Use g_assert_cmpuint where appropriate Eric Blake
2023-05-08 20:03 ` [PATCH 03/11] test-cutils: Test integral qemu_strto* value on failures Eric Blake
2023-05-08 20:03 ` Eric Blake [this message]
2023-05-08 20:03 ` [PATCH 05/11] test-cutils: Prepare for upcoming semantic change in qemu_strtosz Eric Blake
2023-05-08 20:03 ` [PATCH 06/11] test-cutils: Add more coverage to qemu_strtosz Eric Blake
2023-05-09 12:31 ` Hanna Czenczek
2023-05-09 12:42 ` Hanna Czenczek
2023-05-09 16:06 ` Eric Blake
2023-05-09 15:15 ` Hanna Czenczek
2023-05-09 15:50 ` Eric Blake
2023-05-09 16:10 ` Eric Blake
2023-05-08 20:03 ` [PATCH 07/11] numa: Check for qemu_strtosz_MiB error Eric Blake
2023-05-08 21:15 ` Eric Blake
2023-05-08 20:03 ` [PATCH 08/11] cutils: Set value in all qemu_strtosz* error paths Eric Blake
2023-05-08 20:03 ` [PATCH 09/11] cutils: Set value in all integral qemu_strto* " Eric Blake
2023-05-08 20:03 ` [PATCH 10/11] cutils: Improve qemu_strtod* " Eric Blake
2023-05-08 20:03 ` [PATCH 11/11] cutils: Improve qemu_strtosz handling of fractions Eric Blake
2023-05-08 21:21 ` Eric Blake
2023-05-09 17:54 ` Hanna Czenczek
2023-05-09 21:28 ` Eric Blake
2023-05-10 7:46 ` Hanna Czenczek
2023-05-10 7:48 ` Hanna Czenczek
2023-05-09 17:55 ` [PATCH 00/11] Fix qemu_strtosz() read-out-of-bounds Hanna Czenczek
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20230508200343.791450-5-eblake@redhat.com \
--to=eblake@redhat.com \
--cc=hreitz@redhat.com \
--cc=qemu-devel@nongnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).