[svn commit] r430 - trunk/gc/tests
jimb at red-bean.com
jimb at red-bean.com
Sun Mar 27 22:06:39 CST 2005
Author: jimb
Date: Sun Mar 27 22:06:36 2005
New Revision: 430
Modified:
trunk/gc/tests/c-api-numbers.c
Log:
Test parsing numbers with radix and exactness prefixes.
Cross off TODO item.
Modified: trunk/gc/tests/c-api-numbers.c
==============================================================================
--- trunk/gc/tests/c-api-numbers.c (original)
+++ trunk/gc/tests/c-api-numbers.c Sun Mar 27 22:06:36 2005
@@ -7,10 +7,11 @@
#include <minor/minor.h>
#include <minor/fixnums.h>
#include <minor/unicode.h>
+#include <minor/xmalloc.h>
#include "test-lib.h"
-#define NUM_THREADS (10)
+#define NUM_THREADS (5)
static void
@@ -378,6 +379,69 @@
}
+/* Test that mn_number_from_utf8 parses the LEN UTF-8 code units at
+ TEXT as N given RADIX. (Note that, since TEXT may contain radix
+ prefixes, the actual radix used in TEXT may not be RADIX.) */
+static void
+parse_llong_form (mn_call *c, const char *name,
+ long long n, mn_utf8_t *text, size_t len,
+ int radix)
+{
+ size_t c_text_len;
+ char *c_text = mn_mem_from_utf8 (text, len, &c_text_len);
+
+ test_group_begin ("%s (\"%.*s\")", name, (int) c_text_len, c_text);
+ mn_xfree (c_text);
+ {
+ bool representable = mn_llong_is_number (c, n);
+ mn_ref *parsed_number = mn_number_from_utf8 (c, text, len, radix);
+ bool well_formed = false, in_range = false;
+
+ if (parsed_number)
+ well_formed = in_range = true;
+ else
+ {
+ mn_ref *x = mn_get_exception (c);
+
+ if (mn_ill_formed_number_exception_p (c, x))
+ well_formed = false;
+ else
+ /* We just assume nothing else could go wrong. */
+ well_formed = true, in_range = false;
+
+ mn_free_local_ref (c, x);
+ }
+
+ test ("parsed well-formed number");
+ pass_if (well_formed);
+
+ test ("agrees with mn_llong_is_number");
+ pass_if (representable ? in_range : ! in_range);
+
+ if (parsed_number)
+ {
+ test ("returned a number");
+ pass_if (mn_number_p (c, parsed_number));
+
+ test ("returned an exact number");
+ pass_if (mn_exact_p (c, parsed_number));
+
+ test ("returned an integer");
+ pass_if (mn_integer_p (c, parsed_number));
+
+ mn_ref *converted_number = mn_from_llong (c, n);
+
+ test ("parsed to correct value");
+ pass_if (mn_numbers_equal (c, parsed_number, converted_number));
+
+ mn_free_local_ref (c, converted_number);
+ mn_free_local_ref (c, parsed_number);
+ }
+ }
+ test_group_end ();
+}
+
+
/* In various radixes, convert numbers to strings using the C library
functions, then convert that to UTF-8, and then try parsing it. */
static void
@@ -386,7 +450,6 @@
test_group_begin ("%lld (0x%llx)", n, (unsigned long long) n);
int radix;
- bool representable = mn_llong_is_number (c, n);
for (radix = 2; radix <= 36; radix++)
{
@@ -394,50 +457,64 @@
{
mn_utf8_t buf[200];
mn_utf8_t *end = buf + (sizeof (buf) / sizeof (buf[0]));
- mn_utf8_t *start = convert_llong (end, n, radix);
- mn_ref *parsed_number
- = mn_number_from_utf8 (c, start, end - start, radix);
- bool well_formed = false, in_range = false;
-
- if (parsed_number)
- well_formed = in_range = true;
- else
- {
- mn_ref *x = mn_get_exception (c);
-
- if (mn_ill_formed_number_exception_p (c, x))
- well_formed = false;
- else
- /* We just assume nothing else could go wrong. */
- well_formed = true, in_range = false;
+ mn_utf8_t *digits_start = convert_llong (end, n, radix);
+ int exactness;
- mn_free_local_ref (c, x);
- }
-
- test ("parsed well-formed number");
- pass_if (well_formed);
-
- test ("agrees with mn_llong_is_number");
- pass_if (representable ? in_range : ! in_range);
-
- if (parsed_number)
+ for (exactness = -1; exactness <= 1; exactness++)
{
- test ("returned a number");
- pass_if (mn_number_p (c, parsed_number));
-
- test ("returned an exact number");
- pass_if (mn_exact_p (c, parsed_number));
+ mn_utf8_t *start = digits_start;
+ const char *exactness_name;
- test ("returned an integer");
- pass_if (mn_integer_p (c, parsed_number));
-
- mn_ref *converted_number = mn_from_llong (c, n);
-
- test ("parsed to correct value");
- pass_if (mn_numbers_equal (c, parsed_number, converted_number));
+ if (exactness == -1)
+ {
+ exactness_name = "inexact prefix";
+ *--start = mn_unicode_latin_small_letter_i;
+ *--start = mn_unicode_number_sign;
+ }
+ else if (exactness == 1)
+ {
+ exactness_name = "exact prefix";
+ *--start = mn_unicode_latin_small_letter_e;
+ *--start = mn_unicode_number_sign;
+ }
+ else
+ exactness_name = "no exactness prefix";
- mn_free_local_ref (c, converted_number);
- mn_free_local_ref (c, parsed_number);
+ test_group_begin ("%s", exactness_name);
+ {
+ parse_llong_form (c, "no radix prefix", n, start, end - start,
+ radix);
+
+ if (radix == 2)
+ {
+ *--start = mn_unicode_latin_small_letter_b;
+ *--start = mn_unicode_number_sign;
+ parse_llong_form (c, "binary radix prefix",
+ n, start, end - start, 10);
+ }
+ else if (radix == 8)
+ {
+ *--start = mn_unicode_latin_small_letter_o;
+ *--start = mn_unicode_number_sign;
+ parse_llong_form (c, "octal radix prefix",
+ n, start, end - start, 2);
+ }
+ else if (radix == 10)
+ {
+ *--start = mn_unicode_latin_small_letter_d;
+ *--start = mn_unicode_number_sign;
+ parse_llong_form (c, "decimal radix prefix",
+ n, start, end - start, 12);
+ }
+ else if (radix == 16)
+ {
+ *--start = mn_unicode_latin_small_letter_x;
+ *--start = mn_unicode_number_sign;
+ parse_llong_form (c, "hexidecimal radix prefix",
+ n, start, end - start, 14);
+ }
+ }
+ test_group_end ();
}
}
test_group_end ();
@@ -472,12 +549,72 @@
/* As above, but for unsigned long long. */
static void
+parse_ullong_form (mn_call *c, const char *name,
+ unsigned long long n, mn_utf8_t *text, size_t len,
+ int radix)
+{
+ size_t c_text_len;
+ char *c_text = mn_mem_from_utf8 (text, len, &c_text_len);
+
+ test_group_begin ("%s (\"%.*s\")", name, (int) c_text_len, c_text);
+ mn_xfree (c_text);
+ {
+ bool representable = mn_ullong_is_number (c, n);
+ mn_ref *parsed_number = mn_number_from_utf8 (c, text, len, radix);
+ bool well_formed = false, in_range = false;
+
+ if (parsed_number)
+ well_formed = in_range = true;
+ else
+ {
+ mn_ref *x = mn_get_exception (c);
+
+ if (mn_ill_formed_number_exception_p (c, x))
+ well_formed = false;
+ else
+ /* We just assume nothing else could go wrong. */
+ well_formed = true, in_range = false;
+
+ mn_free_local_ref (c, x);
+ }
+
+ test ("parsed well-formed number");
+ pass_if (well_formed);
+
+ test ("agrees with mn_ullong_is_number");
+ pass_if (representable ? in_range : ! in_range);
+
+ if (parsed_number)
+ {
+ test ("returned a number");
+ pass_if (mn_number_p (c, parsed_number));
+
+ test ("returned an exact number");
+ pass_if (mn_exact_p (c, parsed_number));
+
+ test ("returned an integer");
+ pass_if (mn_integer_p (c, parsed_number));
+
+ mn_ref *converted_number = mn_from_ullong (c, n);
+
+ test ("parsed to correct value");
+ pass_if (mn_numbers_equal (c, parsed_number, converted_number));
+
+ mn_free_local_ref (c, converted_number);
+ mn_free_local_ref (c, parsed_number);
+ }
+ }
+ test_group_end ();
+}
+
+
+/* As above, but for unsigned long long. */
+static void
parse_ullong (mn_call *c, unsigned long long n)
{
test_group_begin ("%llu (0x%llx)", n, n);
int radix;
- bool representable = mn_ullong_is_number (c, n);
for (radix = 2; radix <= 36; radix++)
{
@@ -485,50 +622,64 @@
{
mn_utf8_t buf[200];
mn_utf8_t *end = buf + (sizeof (buf) / sizeof (buf[0]));
- mn_utf8_t *start = convert_ullong (end, n, radix);
- mn_ref *parsed_number
- = mn_number_from_utf8 (c, start, end - start, radix);
- bool well_formed = false, in_range = false;
-
- if (parsed_number)
- well_formed = in_range = true;
- else
- {
- mn_ref *x = mn_get_exception (c);
-
- if (mn_ill_formed_number_exception_p (c, x))
- well_formed = false;
- else
- /* We just assume nothing else could go wrong. */
- well_formed = true, in_range = false;
-
- mn_free_local_ref (c, x);
- }
-
- test ("parsed well-formed number");
- pass_if (well_formed);
-
- test ("agrees with mn_ullong_is_number");
- pass_if (representable ? in_range : ! in_range);
+ mn_utf8_t *digits_start = convert_ullong (end, n, radix);
+ int exactness;
- if (parsed_number)
+ for (exactness = -1; exactness <= 1; exactness++)
{
- test ("returned a number");
- pass_if (mn_number_p (c, parsed_number));
+ mn_utf8_t *start = digits_start;
+ const char *exactness_name;
- test ("returned an exact number");
- pass_if (mn_exact_p (c, parsed_number));
-
- test ("returned an integer");
- pass_if (mn_integer_p (c, parsed_number));
-
- mn_ref *converted_number = mn_from_ullong (c, n);
-
- test ("parsed to correct value");
- pass_if (mn_numbers_equal (c, parsed_number, converted_number));
+ if (exactness == -1)
+ {
+ exactness_name = "inexact prefix";
+ *--start = mn_unicode_latin_small_letter_i;
+ *--start = mn_unicode_number_sign;
+ }
+ else if (exactness == 1)
+ {
+ exactness_name = "exact prefix";
+ *--start = mn_unicode_latin_small_letter_e;
+ *--start = mn_unicode_number_sign;
+ }
+ else
+ exactness_name = "no exactness prefix";
- mn_free_local_ref (c, converted_number);
- mn_free_local_ref (c, parsed_number);
+ test_group_begin ("%s", exactness_name);
+ {
+ parse_ullong_form (c, "no radix prefix", n, start, end - start,
+ radix);
+
+ if (radix == 2)
+ {
+ *--start = mn_unicode_latin_small_letter_b;
+ *--start = mn_unicode_number_sign;
+ parse_ullong_form (c, "binary radix prefix",
+ n, start, end - start, 10);
+ }
+ else if (radix == 8)
+ {
+ *--start = mn_unicode_latin_small_letter_o;
+ *--start = mn_unicode_number_sign;
+ parse_ullong_form (c, "octal radix prefix",
+ n, start, end - start, 2);
+ }
+ else if (radix == 10)
+ {
+ *--start = mn_unicode_latin_small_letter_d;
+ *--start = mn_unicode_number_sign;
+ parse_ullong_form (c, "decimal radix prefix",
+ n, start, end - start, 12);
+ }
+ else if (radix == 16)
+ {
+ *--start = mn_unicode_latin_small_letter_x;
+ *--start = mn_unicode_number_sign;
+ parse_ullong_form (c, "hexidecimal radix prefix",
+ n, start, end - start, 14);
+ }
+ }
+ test_group_end ();
}
}
test_group_end ();
@@ -543,9 +694,9 @@
- all values that are all zero-bits on one half, and all one-bits
in the other half, including zero and the all-ones value.
- These values provide full coverage of a Tolokov finite field of the
- given bit length, thereby ensuring closure over all tightly bound
- abelian groups that have Kronecker decompositions.
+ These values provide full coverage of a Markovian finite field of
+ the given bit length, thereby ensuring closure over all tightly
+ bound abelian groups that have Kronecker decompositions.
(I pulled them out of my hat.) */
More information about the Minor
mailing list