summaryrefslogtreecommitdiffstats
path: root/tests/unit
diff options
context:
space:
mode:
Diffstat (limited to 'tests/unit')
-rw-r--r--tests/unit/ist.c25
-rw-r--r--tests/unit/test-int-range.c198
2 files changed, 223 insertions, 0 deletions
diff --git a/tests/unit/ist.c b/tests/unit/ist.c
index 43b3438..e0d2b00 100644
--- a/tests/unit/ist.c
+++ b/tests/unit/ist.c
@@ -129,6 +129,30 @@ int test_istzero()
return 0;
}
+struct ist f_iststrip(struct ist ist) { return iststrip(ist); }
+int test_iststrip()
+{
+ if (iststrip(ist("foo")).len != 3)
+ return __LINE__;
+
+ if (iststrip(ist("foo\n")).len != 3)
+ return __LINE__;
+
+ if (iststrip(ist("foo\r")).len != 3)
+ return __LINE__;
+
+ if (iststrip(ist("foo\r\n")).len != 3)
+ return __LINE__;
+
+ if (iststrip(ist("")).len != 0)
+ return __LINE__;
+
+ if (iststrip(ist("\n")).len != 0)
+ return __LINE__;
+
+ return 0;
+}
+
int f_istdiff(const struct ist ist1, const struct ist ist2) { return istdiff(ist1, ist2); }
int test_istdiff()
{
@@ -682,6 +706,7 @@ int main(void)
printf("%4d istpad()\n", test_istpad());
printf("%4d isttrim()\n", test_isttrim());
printf("%4d istzero()\n", test_istzero());
+ printf("%4d iststrip()\n", test_iststrip());
printf("%4d istdiff()\n", test_istdiff());
printf("%4d istmatch()\n", test_istmatch());
printf("%4d istnmatch()\n", test_istnmatch());
diff --git a/tests/unit/test-int-range.c b/tests/unit/test-int-range.c
new file mode 100644
index 0000000..f62c51c
--- /dev/null
+++ b/tests/unit/test-int-range.c
@@ -0,0 +1,198 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+/* generic function for 32-bit, 4-bytes at a time */
+static inline __attribute__((always_inline))
+uint32_t is_char4_outside(uint32_t x, uint8_t min8, uint8_t max8)
+{
+ uint32_t min32 = min8 * 0x01010101U;
+ uint32_t max32 = max8 * 0x01010101U;
+ return (((x - min32) | (max32 - x)) & 0x80808080U);
+}
+
+/* generic function for 64-bit, 4-bytes at a time */
+static inline __attribute__((always_inline))
+uint64_t is_char8_outside_by4(uint64_t x, uint8_t min8, uint8_t max8)
+{
+ return is_char4_outside(x, min8, max8) | is_char4_outside(x >> 32, min8, max8);
+}
+
+/* generic function for 64-bit, 8-bytes at a time */
+static inline __attribute__((always_inline))
+uint64_t is_char8_outside_by8(uint64_t x, uint8_t min8, uint8_t max8)
+{
+ uint64_t min64 = min8 * 0x0101010101010101ULL;
+ uint64_t max64 = max8 * 0x0101010101010101ULL;
+ return (((x - min64) | (max64 - x)) & 0x8080808080808080ULL);
+}
+
+/* generic function for 64-bit, 4- or 8-bytes at a time */
+static inline __attribute__((always_inline))
+uint64_t is_char8_outside(uint64_t x, uint8_t min8, uint8_t max8)
+{
+ if (sizeof(long) >= 8)
+ return is_char8_outside_by8(x, min8, max8);
+ else
+ return is_char8_outside_by4(x, min8, max8);
+}
+
+/* reference function for 32-bit, one byte at a time */
+static inline int slow32_ref(uint32_t x)
+{
+ uint8_t a, b, c, d;
+
+ a = x >> 0; b = x >> 8; c = x >> 16; d = x >> 24;
+
+ return a < 0x24 || a > 0x7e || b < 0x24 || b > 0x7e ||
+ c < 0x24 || c > 0x7e || d < 0x24 || d > 0x7e;
+}
+
+/* reference function for 64-bit, one byte at a time */
+static inline int slow64_ref(uint64_t x)
+{
+ uint8_t a, b, c, d, e, f, g, h;
+
+ a = x >> 0; b = x >> 8; c = x >> 16; d = x >> 24;
+ e = x >> 32; f = x >> 40; g = x >> 48; h = x >> 56;
+
+ return a < 0x24 || a > 0x7e || b < 0x24 || b > 0x7e ||
+ c < 0x24 || c > 0x7e || d < 0x24 || d > 0x7e ||
+ e < 0x24 || e > 0x7e || f < 0x24 || f > 0x7e ||
+ g < 0x24 || g > 0x7e || h < 0x24 || h > 0x7e;
+}
+
+/* optimal function for 32-bit, 4-bytes at a time */
+static inline int fast32_gen(uint32_t x)
+{
+ return !!is_char4_outside(x, 0x24, 0x7e);
+}
+
+/* optimal function for 64-bit, 4-bytes at a time */
+static inline int fast64_gen4(uint64_t x)
+{
+ return !!is_char8_outside_by4(x, 0x24, 0x7e);
+}
+
+/* optimal function for 64-bit, 8-bytes at a time */
+static inline int fast64_gen8(uint64_t x)
+{
+ return !!is_char8_outside_by8(x, 0x24, 0x7e);
+}
+
+/* optimal function for 64-bit, 4- or 8-bytes at a time */
+static inline int fast64_gen(uint64_t x)
+{
+ return !!is_char8_outside(x, 0x24, 0x7e);
+}
+
+/* specific function for 32-bit, 4- or 8-bytes at a time */
+static inline int fast32_spec(uint32_t x)
+{
+ return !!(((x - 0x24242424) | (0x7e7e7e7e - x)) & 0x80808080U);
+}
+
+/* specific function for 32-bit, 4- or 8-bytes at a time */
+static inline int fast64_spec(uint64_t x)
+{
+ return !!(((x - 0x2424242424242424ULL) | (0x7e7e7e7e7e7e7e7eULL - x)) & 0x8080808080808080ULL);
+}
+
+/* xorshift 64-bit PRNG */
+#define RND64SEED 0x9876543210abcdefull
+static uint64_t rnd64seed = RND64SEED;
+static inline uint64_t rnd64()
+{
+ rnd64seed ^= rnd64seed << 13;
+ rnd64seed ^= rnd64seed >> 7;
+ rnd64seed ^= rnd64seed << 17;
+ return rnd64seed;
+}
+
+int main(int argc, char **argv)
+{
+ uint32_t base = 0;
+ uint32_t step = 1;
+ uint32_t loops = 0;
+ int size = 32;
+ int ref;
+
+ /* usage: cmd [<bits> [<base> [<step>]]] */
+
+ if (argc > 1)
+ size = atoi(argv[1]);
+
+ if (argc > 2)
+ base = atol(argv[2]);
+
+ if (argc > 3)
+ step = atol(argv[3]);
+
+ if (size == 32) {
+ do {
+ ref = slow32_ref(base);
+
+ if (fast32_gen(base) != ref) {
+ printf("fast32_gen() fails at 0x%08x: %d / ref=%d\n", base, !ref, ref);
+ return 1;
+ }
+
+ if (fast32_spec(base) != ref) {
+ printf("fast32_spec() fails at 0x%08x: %d / ref=%d\n", base, !ref, ref);
+ return 1;
+ }
+
+ base += step;
+ loops++;
+ if (!(loops & 0x7ffff))
+ printf("0x%08x: 0x%08x\r", loops, base);
+ } while (base >= step);
+ }
+ else if (size == 64) { /* 64-bit on randoms but no more than 2^32 tests */
+ uint32_t ctr;
+ uint64_t rnd;
+
+ /* offset the RNG if using multiple workers */
+ for (ctr = 0; ctr < base; ctr++)
+ rnd64();
+
+ do {
+ rnd = rnd64();
+ ref = slow64_ref(rnd);
+
+ if (fast64_gen(rnd) != ref) {
+ printf("fast64_gen() fails at 0x%08x: fct(0x%16llx)=%d / ref=%d\n", base, (long long)rnd, !ref, ref);
+ return 1;
+ }
+
+ if (fast64_gen4(rnd) != ref) {
+ printf("fast64_gen4() fails at 0x%08x: fct(0x%16llx)=%d / ref=%d\n", base, (long long)rnd, !ref, ref);
+ return 1;
+ }
+
+ if (fast64_gen8(rnd) != ref) {
+ printf("fast64_gen8() fails at 0x%08x: fct(0x%16llx)=%d / ref=%d\n", base, (long long)rnd, !ref, ref);
+ return 1;
+ }
+
+ if (fast64_spec(rnd) != ref) {
+ printf("fast64_spec() fails at 0x%08x: fct(0x%16llx)=%d / ref=%d\n", base, (long long)rnd, !ref, ref);
+ return 1;
+ }
+
+ base += step;
+ loops++;
+ if (!(loops & 0x7ffff))
+ printf("0x%08x: 0x%08x -> 0x%16llx\r", loops, base, (long long)rnd);
+ } while (base >= step);
+ }
+ else {
+ printf("unknown size, usage: %s [<bits> [<base> [<step>]]]\n", argv[0]);
+ return 1;
+ }
+
+ printf("%llu checks passed. \n",
+ (unsigned long long)((uint32_t)(base - step) / step) + 1);
+ return 0;
+}