diff options
author | David Robillard <d@drobilla.net> | 2021-02-25 10:27:59 -0500 |
---|---|---|
committer | David Robillard <d@drobilla.net> | 2021-03-08 23:23:05 -0500 |
commit | c4821c8e6bf1f81c6ea31e11ebc0fc1666e9337b (patch) | |
tree | a62995534f5f606ac2f8bae22d525532b824cb5e /subprojects/exess/test/test_double.c | |
parent | 6bcd18ae60482790b645a345f718e7099250f261 (diff) | |
download | serd-c4821c8e6bf1f81c6ea31e11ebc0fc1666e9337b.tar.gz serd-c4821c8e6bf1f81c6ea31e11ebc0fc1666e9337b.tar.bz2 serd-c4821c8e6bf1f81c6ea31e11ebc0fc1666e9337b.zip |
Add exess from git@gitlab.com:drobilla/exess.git 4638b1f
Diffstat (limited to 'subprojects/exess/test/test_double.c')
-rw-r--r-- | subprojects/exess/test/test_double.c | 246 |
1 files changed, 246 insertions, 0 deletions
diff --git a/subprojects/exess/test/test_double.c b/subprojects/exess/test/test_double.c new file mode 100644 index 00000000..d4901c5a --- /dev/null +++ b/subprojects/exess/test/test_double.c @@ -0,0 +1,246 @@ +/* + Copyright 2011-2021 David Robillard <d@drobilla.net> + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#undef NDEBUG + +#include "float_test_data.h" +#include "int_test_data.h" +#include "num_test_utils.h" +#include "string_utils.h" + +#include "exess/exess.h" + +#include <assert.h> +#include <float.h> +#include <math.h> +#include <stdint.h> +#include <stdio.h> +#include <string.h> + +static void +check_read(const char* const string, + const ExessStatus expected_status, + const double expected_value, + const size_t expected_count) +{ + double value = (double)NAN; + const ExessResult r = exess_read_double(&value, string); + + assert(r.status == expected_status); + assert(r.count == expected_count); + assert(double_matches(value, expected_value)); +} + +static void +test_read_double(void) +{ + // Limits + check_read("-1.7976931348623157E308", EXESS_SUCCESS, -DBL_MAX, 23); + check_read("-2.2250738585072014E-308", EXESS_SUCCESS, -DBL_MIN, 24); + check_read("2.2250738585072014E-308", EXESS_SUCCESS, DBL_MIN, 23); + check_read("1.7976931348623157E308", EXESS_SUCCESS, DBL_MAX, 22); + + // Beyond limits + check_read("1e-326", EXESS_SUCCESS, 0.0, 6); + check_read("12345678901234567123", EXESS_SUCCESS, 12345678901234567000.0, 20); + check_read("1e309", EXESS_SUCCESS, (double)INFINITY, 5); + + // Non-canonical form + check_read("+1E3", EXESS_SUCCESS, 1e3, 4); + check_read("1E+3", EXESS_SUCCESS, 1e3, 4); + check_read("+1.5E3", EXESS_SUCCESS, 1.5e3, 6); + check_read(".5E3", EXESS_SUCCESS, 0.5e3, 4); + check_read("+.5E3", EXESS_SUCCESS, 0.5e3, 5); + check_read("-.5E3", EXESS_SUCCESS, -0.5e3, 5); + check_read("1.E3", EXESS_SUCCESS, 1e3, 4); + check_read("+1.E3", EXESS_SUCCESS, 1e3, 5); + check_read("-1.E3", EXESS_SUCCESS, -1e3, 5); + + // Special values + check_read("NaN", EXESS_SUCCESS, (double)NAN, 3); + check_read("-INF", EXESS_SUCCESS, (double)-INFINITY, 4); + check_read("-0.0E0", EXESS_SUCCESS, -0.0, 6); + check_read("0.0E0", EXESS_SUCCESS, 0.0, 5); + check_read("+0.0E0", EXESS_SUCCESS, 0.0, 6); + check_read("INF", EXESS_SUCCESS, (double)INFINITY, 3); + check_read("+INF", EXESS_SUCCESS, (double)INFINITY, 4); + + // No exponent + check_read("1", EXESS_SUCCESS, 1.0, 1); + check_read("2.3", EXESS_SUCCESS, 2.3, 3); + check_read("-4.5", EXESS_SUCCESS, -4.5, 4); + + // Leading whitespace + check_read(" \f\n\r\t\v1.2", EXESS_SUCCESS, 1.2, 9); + + // Garbage + check_read("true", EXESS_EXPECTED_DIGIT, (double)NAN, 0); + check_read("+true", EXESS_EXPECTED_DIGIT, (double)NAN, 1); + check_read("-false", EXESS_EXPECTED_DIGIT, (double)NAN, 1); + check_read("1.0eX", EXESS_EXPECTED_DIGIT, (double)NAN, 4); + check_read("1.0EX", EXESS_EXPECTED_DIGIT, (double)NAN, 4); +} + +/// Check that `str` is a canonical xsd:double string +static void +check_canonical(const char* const str) +{ + if (!strcmp(str, "NaN") || !strcmp(str, "-INF") || !strcmp(str, "INF")) { + return; + } + + assert(strlen(str) > 4); // Shortest possible is something like 1.2E3 + assert(str[0] == '-' || is_digit(str[0])); + + const int first_digit = str[0] == '-' ? 1 : 0; + assert(is_digit(str[first_digit])); + assert(str[first_digit + 1] == '.'); + assert(is_digit(str[first_digit + 2])); + + const char* const e = strchr(str, 'E'); + assert(e); + assert(*e == 'E'); + assert(*(e + 1) == '-' || is_digit(*(e + 1))); +} + +static void +check_write(const double value, + const ExessStatus expected_status, + const size_t buf_size, + const char* const expected_string) +{ + char buf[EXESS_MAX_DOUBLE_LENGTH + 1] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, // + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, // + 21, 22, 23}; + + assert(buf_size <= sizeof(buf)); + + const ExessResult r = exess_write_double(value, buf_size, buf); + assert(r.status == expected_status); + assert(r.count == strlen(buf)); + assert(!strcmp(buf, expected_string)); + assert((r.status && r.status != EXESS_NO_SPACE) || + exess_write_double(value, 0, NULL).count == r.count); + + if (!r.status) { + check_canonical(buf); + } +} + +static void +test_write_double(void) +{ + check_write((double)NAN, EXESS_SUCCESS, 4, "NaN"); + check_write(DBL_MIN, EXESS_SUCCESS, 24, "2.2250738585072014E-308"); + check_write(-0.0, EXESS_SUCCESS, 7, "-0.0E0"); + check_write(0.0, EXESS_SUCCESS, 6, "0.0E0"); + check_write(DBL_MAX, EXESS_SUCCESS, 23, "1.7976931348623157E308"); + + /* check_write((double)NAN, EXESS_NO_SPACE, 3, ""); */ + /* check_write(DBL_MIN, EXESS_SUCCESS, 24, "2.2250738585072014E-308"); */ + /* check_write(-0.0, EXESS_SUCCESS, 7, "-0.0E0"); */ + /* check_write(0.0, EXESS_SUCCESS, 6, "0.0E0"); */ + /* check_write(DBL_MAX, EXESS_SUCCESS, 23, "1.7976931348623157E308"); */ +} + +static void +check_round_trip(const double value) +{ + double parsed_value = 0.0; + + char buf[EXESS_MAX_DOUBLE_LENGTH + 1] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, // + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, // + 21, 22, 23}; + + assert(!exess_write_double(value, sizeof(buf), buf).status); + assert(!exess_read_double(&parsed_value, buf).status); + assert(double_matches(parsed_value, value)); +} + +static void +test_round_trip(const ExessNumTestOptions opts) +{ + check_round_trip((double)NAN); + check_round_trip(-(double)INFINITY); + check_round_trip(DBL_MIN); + check_round_trip(-0.0); + check_round_trip(0.0); + check_round_trip(DBL_MAX); + check_round_trip((double)INFINITY); + + check_round_trip(5.0); + check_round_trip(50.0); + check_round_trip(500000000000000000000.0); + check_round_trip(-0.5); + check_round_trip(0.5); + check_round_trip(0.05); + check_round_trip(0.005); + check_round_trip(0.00000000000000000005); + + // Normal limits + check_round_trip(nextafter(DBL_MIN, (double)INFINITY)); + check_round_trip(nextafter(DBL_EPSILON, (double)INFINITY)); + check_round_trip(nextafter(DBL_MAX, -(double)INFINITY)); + + // Subnormals + check_round_trip(nextafter(0.0, 1.0)); + check_round_trip(nextafter(nextafter(0.0, 1.0), 2.0)); + check_round_trip(nextafter(0.0, -1.0)); + check_round_trip(nextafter(nextafter(0.0, -1.0), -2.0)); + + // Various tricky cases + check_round_trip(1e23); + check_round_trip(6.02951420360127e-309); + check_round_trip(9.17857104364115e+288); + check_round_trip(2.68248422823759e+22); + + // Powers of two (where the lower boundary is closer) + for (int i = -1023; i <= 1023; ++i) { + check_round_trip(pow(2, i)); + } + + fprintf(stderr, "Testing xsd:double randomly with seed %u\n", opts.seed); + + uint64_t rep = opts.seed; + for (uint64_t i = 0; i < opts.n_tests; ++i) { + rep = lcg64(rep); + + const double value = double_from_rep(rep); + + check_round_trip(nextafter(value, -(double)INFINITY)); + check_round_trip(value); + check_round_trip(nextafter(value, (double)INFINITY)); + + print_num_test_progress(i, opts.n_tests); + } +} + +int +main(int argc, char** argv) +{ + const ExessNumTestOptions opts = parse_num_test_options(argc, argv); + if (opts.error) { + return 1; + } + + test_read_double(); + test_write_double(); + test_round_trip(opts); + + return 0; +} |