added pdclib, removed sash

4 files changed, 789 insertions, 0 deletions

diff --git a/src/pdclib/testing/_PDCLIB_iotest.h b/src/pdclib/testing/_PDCLIB_iotest.h
new file mode 100644
index 0000000..ef4d771
--- /dev/null
+++ b/src/pdclib/testing/_PDCLIB_iotest.h
@@ -0,0 +1,223 @@
+/* PDCLib testing suite <_PDCLIB_test.h>
+
+   This file is part of the Public Domain C Library (PDCLib).
+   Permission is granted to use, modify, and / or redistribute at will.
+*/
+
+/* -------------------------------------------------------------------------- */
+/* Helper macros for printf() / scanf() tests                                 */
+/* -------------------------------------------------------------------------- */
+/* Tucked away in a seperate header because these are ugly, complex, and not  */
+/* needed in 95% of all test cases.                                           */
+/* -------------------------------------------------------------------------- */
+
+/* ...printf() tests */
+#if defined( _PDCLIB_FILEIO )
+   #define GET_RESULT \
+      rewind( target ); \
+      if ( (int)fread( result_buffer, 1, actual_rc, target ) != actual_rc ) \
+      { \
+          fprintf( stderr, "GET_RESULT failed." ); \
+      }
+   #define RESULT_MISMATCH( act, exp ) strcmp( result_buffer, exp ) != 0
+   #define RESULT_STRING( tgt ) result_buffer
+#elif defined( _PDCLIB_STRINGIO )
+   #define RESULT_MISMATCH( act, exp ) strcmp( act, exp ) != 0
+   #define GET_RESULT
+   #define RESULT_STRING( tgt ) tgt
+#endif
+
+#ifdef _PDCLIB_FILEIO
+#define PREP_RESULT_BUFFER char result_buffer[100] = { 0 }; rewind( target );
+#else
+#define PREP_RESULT_BUFFER
+#endif
+
+#define GETFMT( fmt, ... ) (fmt)
+#define PRINTF_TEST( expected_rc, expected_string, ... ) do { \
+        int actual_rc; \
+        PREP_RESULT_BUFFER \
+        actual_rc = testprintf( target, __VA_ARGS__ ); \
+        GET_RESULT \
+        if ( ( actual_rc != expected_rc ) || \
+             ( RESULT_MISMATCH( target, expected_string ) ) ) \
+        { \
+            ++TEST_RESULTS; \
+            fprintf( stderr, \
+                "FAILED: " __FILE__ " (" _PDCLIB_FILEID "), line %d\n" \
+                "        format string \"%s\"\n" \
+                "        expected %2d, \"%s\"\n" \
+                "        actual   %2d, \"%s\"\n", \
+                 __LINE__, GETFMT(__VA_ARGS__, 0), expected_rc, \
+                 expected_string, actual_rc, RESULT_STRING( target ) ); \
+        } \
+    } while ( 0 )
+
+/* ...scanf() tests */
+#if defined( _PDCLIB_FILEIO )
+    #define PREPARE_SOURCE( input_string ) \
+        rewind( source ); \
+        fwrite( input_string, 1, sizeof( input_string ), source ); \
+        rewind( source );
+#elif defined( _PDCLIB_STRINGIO )
+    #define PREPARE_SOURCE( input_string ) \
+        memcpy( source, input_string, sizeof( input_string ) );
+#endif
+
+#define SCANF_TEST( expected_rc, input_string, ... ) do { \
+        int actual_rc; \
+        PREPARE_SOURCE( input_string ); \
+        actual_rc = testscanf( source, __VA_ARGS__ ); \
+        if ( actual_rc != expected_rc ) \
+        { \
+            ++TEST_RESULTS; \
+            fprintf( stderr, "FAILED: " __FILE__ " (" _PDCLIB_FILEID "), line %d\n        expected %2d,        actual   %2d\n", __LINE__, expected_rc, actual_rc ); \
+        } \
+    } while ( 0 )
+
+/* Virtually everything in the printf() / scanf() test drivers is heavily
+   depending on the platform, i.e. the width of the integer values. To do
+   proper domain tests, we need the limits of the integers (largest and
+   smallest value), which we can get from <limits.h>. But we also need the
+   string representations of these numbers, to the various bases, which of
+   course vary depending on how the platform defines 'int' and 'long'.
+*/
+
+#define sym2v( x ) #x
+#define sym2s( x ) sym2v( x )
+
+#if INT_MAX >> 15 == 1
+
+#define UINT_DIG 5
+#define INT_DIG  5
+#define INT_DIG_LESS1 "4"
+#define INT_DIG_PLUS1 "6"
+#define INT_DIG_PLUS2 "7"
+#define INT_HEXDIG "FFF"
+#define INT_hexdig "fff"
+#define INT_OCTDIG "177777"
+#define INT_MAX_DEZ_STR  "32767"
+#define INT_MIN_DEZ_STR  "32768"
+#define UINT_MAX_DEZ_STR "65535"
+#define INT_MAX_OCT_STR
+#define INT_MIN_OCT_STR
+#define UINT_MAX_OCT_STR
+#define INT_MAX_HEX_STR
+#define INT_MIN_HEX_STR
+#define UINT_MAX_HEX_STR
+
+#elif UINT_MAX >> 31 == 1
+
+#define UINT_DIG 10
+#define INT_DIG  10
+#define INT_DIG_LESS1 "9"
+#define INT_DIG_PLUS1 "11"
+#define INT_DIG_PLUS2 "12"
+#define INT_HEXDIG "FFFFFFF"
+#define INT_hexdig "fffffff"
+#define INT_OCTDIG "37777777777"
+#define INT_MAX_DEZ_STR  "2147483647"
+#define INT_MIN_DEZ_STR  "2147483648"
+#define UINT_MAX_DEZ_STR "4294967295"
+#define INT_MAX_OCT_STR
+#define INT_MIN_OCT_STR
+#define UINT_MAX_OCT_STR
+#define INT_MAX_HEX_STR
+#define INT_MIN_HEX_STR
+#define UINT_MAX_HEX_STR
+
+#elif UINT_MAX >> 63 == 1
+
+#define UINT_DIG 20
+#define INT_DIG  19
+#define INT_DIG_LESS1 "18"
+#define INT_DIG_PLUS1 "20"
+#define INT_DIG_PLUS2 "21"
+#define INT_HEXDIG "FFFFFFFFFFFFFFF"
+#define INT_hexdig "fffffffffffffff"
+#define INT_OCTDIG "1777777777777777777777"
+#define INT_MAX_DEZ_STR   "9223372036854775807"
+#define INT_MIN_DEZ_STR   "9223372036854775808"
+#define UINT_MAX_DEZ_STR "18446744073709551615"
+#define INT_MAX_OCT_STR
+#define INT_MIN_OCT_STR
+#define UINT_MAX_OCT_STR
+#define INT_MAX_HEX_STR
+#define INT_MIN_HEX_STR
+#define UINT_MAX_HEX_STR
+
+#else
+
+#error Unsupported width of 'int' (neither 16, 32, nor 64 bit).
+
+#endif
+
+
+#if ULONG_MAX >> 31 == 1
+
+#define ULONG_DIG 10
+#define LONG_DIG  10
+#define LONG_MAX_DEZ_STR  "2147483647"
+#define LONG_MIN_DEZ_STR  "2147483648"
+#define ULONG_MAX_DEZ_STR "4294967295"
+#define LONG_MAX_OCT_STR
+#define LONG_MIN_OCT_STR
+#define ULONG_MAX_OCT_STR
+#define LONG_MAX_HEX_STR
+#define LONG_MIN_HEX_STR
+#define ULONG_MAX_HEX_STR
+
+#elif ULONG_MAX >> 63 == 1
+
+#define ULONG_DIG 20
+#define LONG_DIG  19
+#define LONG_MAX_DEZ_STR   "9223372036854775807"
+#define LONG_MIN_DEZ_STR   "9223372036854775808"
+#define ULONG_MAX_DEZ_STR "18446744073709551615"
+#define LONG_MAX_OCT_STR
+#define LONG_MIN_OCT_STR
+#define ULONG_MAX_OCT_STR
+#define LONG_MAX_HEX_STR
+#define LONG_MIN_HEX_STR
+#define ULONG_MAX_HEX_STR
+
+#else
+
+#error Unsupported width of 'long' (neither 32 nor 64 bit).
+
+#endif
+
+
+#if ULLONG_MAX >> 63 == 1
+
+#define ULLONG_DIG 20
+#define LLONG_DIG  19
+#define LLONG_MAX_DEZ_STR   "9223372036854775807"
+#define LLONG_MIN_DEZ_STR   "9223372036854775808"
+#define ULLONG_MAX_DEZ_STR "18446744073709551615"
+#define LLONG_MAX_OCT_STR
+#define LLONG_MIN_OCT_STR
+#define ULLONG_MAX_OCT_STR
+#define LLONG_MAX_HEX_STR
+#define LLONG_MIN_HEX_STR
+#define ULLONG_MAX_HEX_STR
+
+#elif ULLONG_MAX >> 127 == 1
+
+#define ULLONG_DIG 38
+#define LLONG_DIG  38
+#define LLONG_MAX_DEZ_STR  "170141183460469231731687303715884105727"
+#define LLONG_MIN_DEZ_STR  "170141183460469231731687303715884105728"
+#define ULLONG_MAX_DEZ_STR "340282366920938463463374607431768211455"
+#define LLONG_MAX_OCT_STR
+#define LLONG_MIN_OCT_STR
+#define ULLONG_MAX_OCT_STR
+#define LLONG_MAX_HEX_STR
+#define LLONG_MIN_HEX_STR
+#define ULLONG_MAX_HEX_STR
+
+#else
+
+#error Unsupported width of 'long long' (neither 64 nor 128 bit).
+
+#endif
diff --git a/src/pdclib/testing/_PDCLIB_test.h b/src/pdclib/testing/_PDCLIB_test.h
new file mode 100644
index 0000000..65cf5b5
--- /dev/null
+++ b/src/pdclib/testing/_PDCLIB_test.h
@@ -0,0 +1,45 @@
+/* PDCLib testing suite <_PDCLIB_test.h>
+
+   This file is part of the Public Domain C Library (PDCLib).
+   Permission is granted to use, modify, and / or redistribute at will.
+*/
+
+/* -------------------------------------------------------------------------- */
+/* Helper macros for test drivers                                             */
+/* -------------------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <limits.h>
+#include <string.h>
+#include <assert.h>
+
+/* Some strings used for <string.h> and <stdlib.h> testing. */
+static const char abcde[] = "abcde";
+static const char abcdx[] = "abcdx";
+static const char teststring[] = "1234567890\nABCDEFGHIJKLMNOPQRSTUVWXYZ\nabcdefghijklmnopqrstuvwxyz\n";
+
+/* Temporary file names */
+static const char testfile[]="testing/testfile";
+static const char testfile1[]="testing/testfile1";
+static const char testfile2[]="testing/testfile2";
+
+#define NO_TESTDRIVER 0
+
+static int TEST_RESULTS = 0;
+
+/* TESTCASE() - generic test */
+#define TESTCASE( x ) if ( x ) {} \
+                      else { TEST_RESULTS += 1; printf( "FAILED: " __FILE__ ", line %d - %s\n", __LINE__, #x ); }
+
+/* TESTCASE_NOREG() - PDCLib-only test */
+#ifndef REGTEST
+    #define TESTCASE_NOREG( x ) TESTCASE( x )
+#else
+    #define TESTCASE_NOREG( x )
+#endif
+
+/* Include printf() / scanf() test macros if required */
+
+#if defined( _PDCLIB_FILEIO ) || defined( _PDCLIB_STRINGIO )
+#include "_PDCLIB_iotest.h"
+#endif
diff --git a/src/pdclib/testing/printf_testcases.h b/src/pdclib/testing/printf_testcases.h
new file mode 100644
index 0000000..c714499
--- /dev/null
+++ b/src/pdclib/testing/printf_testcases.h
@@ -0,0 +1,434 @@
+    {
+#if CHAR_MIN == -128
+    assert(CHAR_MIN == -128);
+    PRINTF_TEST( 4,   "-128", "%hhd", CHAR_MIN );
+    assert(CHAR_MAX == 127);
+    PRINTF_TEST( 3,    "127", "%hhd", CHAR_MAX );
+#else
+    assert(CHAR_MIN == 0);
+    PRINTF_TEST( 1,   "0", "%hhu", CHAR_MIN );
+    assert(CHAR_MAX == 255);
+    PRINTF_TEST( 3,    "255", "%hhu", CHAR_MAX );
+#endif
+    PRINTF_TEST( 1,      "0", "%hhd", 0 );
+    assert(SHRT_MIN == -32768);
+    PRINTF_TEST( 6, "-32768",  "%hd", SHRT_MIN );
+    assert(SHRT_MAX == 32767);
+    PRINTF_TEST( 5,  "32767",  "%hd", SHRT_MAX );
+    PRINTF_TEST( 1,      "0",  "%hd", 0 );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%d", INT_MIN );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%d", INT_MAX );
+    PRINTF_TEST( 1, "0", "%d", 0 );
+    PRINTF_TEST( LONG_DIG + 1, "-" LONG_MIN_DEZ_STR, "%ld", LONG_MIN );
+    PRINTF_TEST( LONG_DIG, LONG_MAX_DEZ_STR, "%ld", LONG_MAX );
+    PRINTF_TEST( 1, "0", "%ld", 0l );
+    PRINTF_TEST( LLONG_DIG + 1, "-" LLONG_MIN_DEZ_STR, "%lld", LLONG_MIN );
+    PRINTF_TEST( LLONG_DIG, LLONG_MAX_DEZ_STR, "%lld", LLONG_MAX );
+    PRINTF_TEST( 1, "0", "%lld", 0ll );
+    PRINTF_TEST( 3, "255", "%hhu", UCHAR_MAX );
+    PRINTF_TEST( 3, "255", "%hhu", (unsigned char)-1 );
+    PRINTF_TEST( 5, "65535", "%hu", USHRT_MAX );
+    PRINTF_TEST( 5, "65535", "%hu", (unsigned short)-1 );
+    PRINTF_TEST( UINT_DIG, UINT_MAX_DEZ_STR, "%u", UINT_MAX );
+    PRINTF_TEST( UINT_DIG, UINT_MAX_DEZ_STR, "%u", -1u );
+    PRINTF_TEST( ULONG_DIG, ULONG_MAX_DEZ_STR, "%lu", ULONG_MAX );
+    PRINTF_TEST( ULONG_DIG, ULONG_MAX_DEZ_STR, "%lu", -1ul );
+    PRINTF_TEST( ULLONG_DIG, ULLONG_MAX_DEZ_STR, "%llu", ULLONG_MAX );
+    PRINTF_TEST( ULLONG_DIG, ULLONG_MAX_DEZ_STR, "%llu", -1ull );
+    PRINTF_TEST( (int)strlen( INT_HEXDIG ) + 1, "F" INT_HEXDIG, "%X", UINT_MAX );
+    PRINTF_TEST( (int)strlen( INT_HEXDIG ) + 3, "0XF" INT_HEXDIG, "%#X", -1u );
+    PRINTF_TEST( (int)strlen( INT_HEXDIG ) + 1, "f" INT_hexdig, "%x", UINT_MAX );
+    PRINTF_TEST( (int)strlen( INT_HEXDIG ) + 3, "0xf" INT_hexdig, "%#x", -1u );
+    PRINTF_TEST( (int)strlen( INT_OCTDIG ), INT_OCTDIG, "%o", UINT_MAX );
+    PRINTF_TEST( (int)strlen( INT_OCTDIG ) + 1, "0" INT_OCTDIG, "%#o", -1u );
+#if 0
+    /* TODO: This test case is broken, doesn't test what it was intended to. */
+    PRINTF_TEST( 5, "%.0#o", "%.0#o", 0 );
+#endif
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%+d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 1, "+" INT_MAX_DEZ_STR, "%+d", INT_MAX );
+    PRINTF_TEST( 2, "+0", "%+d", 0 );
+    PRINTF_TEST( UINT_DIG, UINT_MAX_DEZ_STR, "%+u", UINT_MAX );
+    PRINTF_TEST( UINT_DIG, UINT_MAX_DEZ_STR, "%+u", -1u );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "% d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 1, " " INT_MAX_DEZ_STR, "% d", INT_MAX );
+    PRINTF_TEST( 2, " 0", "% d", 0 );
+    PRINTF_TEST( UINT_DIG, UINT_MAX_DEZ_STR, "% u", UINT_MAX );
+    PRINTF_TEST( UINT_DIG, UINT_MAX_DEZ_STR, "% u", -1u );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%" INT_DIG_LESS1 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%" INT_DIG_LESS1 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%" sym2s(INT_DIG) "d", INT_MIN );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%" sym2s(INT_DIG) "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%" INT_DIG_PLUS1 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 1, " " INT_MAX_DEZ_STR, "%" INT_DIG_PLUS1 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 2, " -" INT_MIN_DEZ_STR, "%" INT_DIG_PLUS2 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 2, "  " INT_MAX_DEZ_STR, "%" INT_DIG_PLUS2 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%-" INT_DIG_LESS1 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%-" INT_DIG_LESS1 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%-" sym2s(INT_DIG) "d", INT_MIN );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%-" sym2s(INT_DIG) "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%-" INT_DIG_PLUS1 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 1, INT_MAX_DEZ_STR " ", "%-" INT_DIG_PLUS1 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 2, "-" INT_MIN_DEZ_STR " ", "%-" INT_DIG_PLUS2 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 2, INT_MAX_DEZ_STR "  ", "%-" INT_DIG_PLUS2 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%0" INT_DIG_LESS1 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%0" INT_DIG_LESS1 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%0" sym2s(INT_DIG) "d", INT_MIN );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%0" sym2s(INT_DIG) "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%0" INT_DIG_PLUS1 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 1, "0" INT_MAX_DEZ_STR, "%0" INT_DIG_PLUS1 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 2, "-0" INT_MIN_DEZ_STR, "%0" INT_DIG_PLUS2 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 2, "00" INT_MAX_DEZ_STR, "%0" INT_DIG_PLUS2 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%-0" INT_DIG_LESS1 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%-0" INT_DIG_LESS1 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%-0" sym2s(INT_DIG) "d", INT_MIN );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%-0" sym2s(INT_DIG) "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%-0" INT_DIG_PLUS1 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 1, INT_MAX_DEZ_STR " ", "%-0" INT_DIG_PLUS1 "d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 2, "-" INT_MIN_DEZ_STR " ", "%-0" INT_DIG_PLUS2 "d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 2, INT_MAX_DEZ_STR "  ", "%-0" INT_DIG_PLUS2 "d", INT_MAX );
+    /* FIXME: This test not yet 32/64 bit agnostic */
+    PRINTF_TEST( 30, "          00000000002147483647", "%030.20d", INT_MAX );
+    PRINTF_TEST( (int)strlen( INT_HEXDIG ) + 1, "f" INT_hexdig, "%.6x", UINT_MAX );
+    PRINTF_TEST( (int)strlen( INT_HEXDIG ) + 3, "0xf" INT_hexdig, "%#6.3x", UINT_MAX );
+    PRINTF_TEST( (int)strlen( INT_HEXDIG ) + 3, "0xf" INT_hexdig, "%#3.6x", UINT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%.6d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%6.3d", INT_MIN );
+    PRINTF_TEST( INT_DIG + 1, "-" INT_MIN_DEZ_STR, "%3.6d", INT_MIN );
+    PRINTF_TEST( UINT_DIG, "0xf" INT_hexdig, "%#0.6x", UINT_MAX );
+    PRINTF_TEST( UINT_DIG, "0xf" INT_hexdig, "%#06.3x", UINT_MAX );
+    PRINTF_TEST( UINT_DIG, "0xf" INT_hexdig, "%#03.6x", UINT_MAX );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%#0.6d", INT_MAX );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%#06.3d", INT_MAX );
+    PRINTF_TEST( INT_DIG, INT_MAX_DEZ_STR, "%#03.6d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "+" INT_MAX_DEZ_STR, "%#+.6d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "+" INT_MAX_DEZ_STR, "%#+6.3d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "+" INT_MAX_DEZ_STR, "%#+3.6d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "+" INT_MAX_DEZ_STR, "%+0.6d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "+" INT_MAX_DEZ_STR, "%+06.3d", INT_MAX );
+    PRINTF_TEST( INT_DIG + 1, "+" INT_MAX_DEZ_STR, "%+03.6d", INT_MAX );
+#ifndef TEST_CONVERSION_ONLY
+    PRINTF_TEST( INT_DIG + 2, "- " INT_MAX_DEZ_STR, "- %d", INT_MAX );
+    PRINTF_TEST( INT_DIG * 2 + 6, "- " INT_MAX_DEZ_STR " % -" INT_MIN_DEZ_STR, "- %d %% %d", INT_MAX, INT_MIN );
+#endif
+    PRINTF_TEST( 1, "x", "%c", 'x' );
+    PRINTF_TEST( 6, "abcdef", "%s", "abcdef" );
+    /* FIXME: This test not yet 32/64 bit agnostic */
+    PRINTF_TEST( 10, "0xdeadbeef", "%p", (void *)0xdeadbeef );
+    PRINTF_TEST( 6, "   0x1", "%#6x", 1 );
+#ifndef TEST_CONVERSION_ONLY
+    {
+        int val1, val2;
+        PRINTF_TEST( 9, "123456789", "123456%n789%n", &val1, &val2 );
+        TESTCASE( val1 == 6 );
+        TESTCASE( val2 == 9 );
+    }
+#endif
+    }
+    /* PDCLIB-20: Verify "unusual" combinations of length and signedness */
+    PRINTF_TEST( 1,  "1", "%tu", (ptrdiff_t)  1); /* unsigned prtdiff_t */
+    PRINTF_TEST( 2, "-1", "%jd", (intmax_t)  -1); /* intmax_t */
+    PRINTF_TEST( 1,  "1", "%ju", (uintmax_t)  1); /* uintmax_t */
+    PRINTF_TEST( 1,  "1", "%zd", (size_t)     1); /* signed size_t */
+
+/******************************************************************************
+ * NOTE: The following test cases are imported from the Tyndur project. They  *
+ *       are therefore under the license of said project, not CC0.            *
+ *       As said code comprises test cases, it does not form part of the      *
+ *       final compiled library, and has no bearing on its licensing.         *
+ *                                                                            *
+ *       See bug PDCLIB-6 for full details                                    *
+ ******************************************************************************/
+/*
+ * Copyright (c) 2011 The tyndur Project. All rights reserved.
+ *
+ * This code is derived from software contributed to the tyndur Project
+ * by Kevin Wolf.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+    {
+#ifndef TEST_CONVERSION_ONLY
+    /* Ein String ohne alles */
+    PRINTF_TEST(12, "Hallo heimur", "Hallo heimur");
+#endif
+    /* Einfache Konvertierungen */
+    PRINTF_TEST(12, "Hallo heimur", "%s", "Hallo heimur");
+    PRINTF_TEST(4, "1024", "%d", 1024);
+    PRINTF_TEST(5, "-1024", "%d", -1024);
+    PRINTF_TEST(4, "1024", "%i", 1024);
+    PRINTF_TEST(5, "-1024", "%i", -1024);
+    PRINTF_TEST(4, "1024", "%u", 1024u);
+    PRINTF_TEST(10, "4294966272", "%u", -1024u);
+    PRINTF_TEST(3, "777", "%o", 0777u);
+    PRINTF_TEST(11, "37777777001", "%o", -0777u);
+    PRINTF_TEST(8, "1234abcd", "%x", 0x1234abcdu);
+    PRINTF_TEST(8, "edcb5433", "%x", -0x1234abcdu);
+    PRINTF_TEST(8, "1234ABCD", "%X", 0x1234abcdu);
+    PRINTF_TEST(8, "EDCB5433", "%X", -0x1234abcdu);
+    PRINTF_TEST(1, "x", "%c", 'x');
+    PRINTF_TEST(1, "%", "%%");
+    /* Mit %c kann man auch Nullbytes ausgeben */
+    PRINTF_TEST(1, "\0", "%c", '\0');
+    /* Vorzeichen erzwingen (Flag +) */
+    PRINTF_TEST(12, "Hallo heimur", "%+s", "Hallo heimur");
+    PRINTF_TEST(5, "+1024", "%+d", 1024);
+    PRINTF_TEST(5, "-1024", "%+d", -1024);
+    PRINTF_TEST(5, "+1024", "%+i", 1024);
+    PRINTF_TEST(5, "-1024", "%+i", -1024);
+    PRINTF_TEST(4, "1024", "%+u", 1024u);
+    PRINTF_TEST(10, "4294966272", "%+u", -1024u);
+    PRINTF_TEST(3, "777", "%+o", 0777u);
+    PRINTF_TEST(11, "37777777001", "%+o", -0777u);
+    PRINTF_TEST(8, "1234abcd", "%+x", 0x1234abcdu);
+    PRINTF_TEST(8, "edcb5433", "%+x", -0x1234abcdu);
+    PRINTF_TEST(8, "1234ABCD", "%+X", 0x1234abcdu);
+    PRINTF_TEST(8, "EDCB5433", "%+X", -0x1234abcdu);
+    PRINTF_TEST(1, "x", "%+c", 'x');
+    /* Vorzeichenplatzhalter erzwingen (Flag <space>) */
+    PRINTF_TEST(12, "Hallo heimur", "% s", "Hallo heimur");
+    PRINTF_TEST(5, " 1024", "% d", 1024);
+    PRINTF_TEST(5, "-1024", "% d", -1024);
+    PRINTF_TEST(5, " 1024", "% i", 1024);
+    PRINTF_TEST(5, "-1024", "% i", -1024);
+    PRINTF_TEST(4, "1024", "% u", 1024u);
+    PRINTF_TEST(10, "4294966272", "% u", -1024u);
+    PRINTF_TEST(3, "777", "% o", 0777u);
+    PRINTF_TEST(11, "37777777001", "% o", -0777u);
+    PRINTF_TEST(8, "1234abcd", "% x", 0x1234abcdu);
+    PRINTF_TEST(8, "edcb5433", "% x", -0x1234abcdu);
+    PRINTF_TEST(8, "1234ABCD", "% X", 0x1234abcdu);
+    PRINTF_TEST(8, "EDCB5433", "% X", -0x1234abcdu);
+    PRINTF_TEST(1, "x", "% c", 'x');
+    /* Flag + hat Vorrang über <space> */
+    PRINTF_TEST(12, "Hallo heimur", "%+ s", "Hallo heimur");
+    PRINTF_TEST(5, "+1024", "%+ d", 1024);
+    PRINTF_TEST(5, "-1024", "%+ d", -1024);
+    PRINTF_TEST(5, "+1024", "%+ i", 1024);
+    PRINTF_TEST(5, "-1024", "%+ i", -1024);
+    PRINTF_TEST(4, "1024", "%+ u", 1024u);
+    PRINTF_TEST(10, "4294966272", "%+ u", -1024u);
+    PRINTF_TEST(3, "777", "%+ o", 0777u);
+    PRINTF_TEST(11, "37777777001", "%+ o", -0777u);
+    PRINTF_TEST(8, "1234abcd", "%+ x", 0x1234abcdu);
+    PRINTF_TEST(8, "edcb5433", "%+ x", -0x1234abcdu);
+    PRINTF_TEST(8, "1234ABCD", "%+ X", 0x1234abcdu);
+    PRINTF_TEST(8, "EDCB5433", "%+ X", -0x1234abcdu);
+    PRINTF_TEST(1, "x", "%+ c", 'x');
+    /* Alternative Form */
+    PRINTF_TEST(4, "0777", "%#o", 0777u);
+    PRINTF_TEST(12, "037777777001", "%#o", -0777u);
+    PRINTF_TEST(10, "0x1234abcd", "%#x", 0x1234abcdu);
+    PRINTF_TEST(10, "0xedcb5433", "%#x", -0x1234abcdu);
+    PRINTF_TEST(10, "0X1234ABCD", "%#X", 0x1234abcdu);
+    PRINTF_TEST(10, "0XEDCB5433", "%#X", -0x1234abcdu);
+    PRINTF_TEST(1, "0", "%#o", 0u);
+    PRINTF_TEST(1, "0", "%#x", 0u);
+    PRINTF_TEST(1, "0", "%#X", 0u);
+    /* Feldbreite: Kleiner als Ausgabe */
+    PRINTF_TEST(12, "Hallo heimur", "%1s", "Hallo heimur");
+    PRINTF_TEST(4, "1024", "%1d", 1024);
+    PRINTF_TEST(5, "-1024", "%1d", -1024);
+    PRINTF_TEST(4, "1024", "%1i", 1024);
+    PRINTF_TEST(5, "-1024", "%1i", -1024);
+    PRINTF_TEST(4, "1024", "%1u", 1024u);
+    PRINTF_TEST(10, "4294966272", "%1u", -1024u);
+    PRINTF_TEST(3, "777", "%1o", 0777u);
+    PRINTF_TEST(11, "37777777001", "%1o", -0777u);
+    PRINTF_TEST(8, "1234abcd", "%1x", 0x1234abcdu);
+    PRINTF_TEST(8, "edcb5433", "%1x", -0x1234abcdu);
+    PRINTF_TEST(8, "1234ABCD", "%1X", 0x1234abcdu);
+    PRINTF_TEST(8, "EDCB5433", "%1X", -0x1234abcdu);
+    PRINTF_TEST(1, "x", "%1c", 'x');
+    /* Feldbreite: Größer als Ausgabe */
+    PRINTF_TEST(20, "               Hallo", "%20s", "Hallo");
+    PRINTF_TEST(20, "                1024", "%20d", 1024);
+    PRINTF_TEST(20, "               -1024", "%20d", -1024);
+    PRINTF_TEST(20, "                1024", "%20i", 1024);
+    PRINTF_TEST(20, "               -1024", "%20i", -1024);
+    PRINTF_TEST(20, "                1024", "%20u", 1024u);
+    PRINTF_TEST(20, "          4294966272", "%20u", -1024u);
+    PRINTF_TEST(20, "                 777", "%20o", 0777u);
+    PRINTF_TEST(20, "         37777777001", "%20o", -0777u);
+    PRINTF_TEST(20, "            1234abcd", "%20x", 0x1234abcdu);
+    PRINTF_TEST(20, "            edcb5433", "%20x", -0x1234abcdu);
+    PRINTF_TEST(20, "            1234ABCD", "%20X", 0x1234abcdu);
+    PRINTF_TEST(20, "            EDCB5433", "%20X", -0x1234abcdu);
+    PRINTF_TEST(20, "                   x", "%20c", 'x');
+    /* Feldbreite: Linksbündig */
+    PRINTF_TEST(20, "Hallo               ", "%-20s", "Hallo");
+    PRINTF_TEST(20, "1024                ", "%-20d", 1024);
+    PRINTF_TEST(20, "-1024               ", "%-20d", -1024);
+    PRINTF_TEST(20, "1024                ", "%-20i", 1024);
+    PRINTF_TEST(20, "-1024               ", "%-20i", -1024);
+    PRINTF_TEST(20, "1024                ", "%-20u", 1024u);
+    PRINTF_TEST(20, "4294966272          ", "%-20u", -1024u);
+    PRINTF_TEST(20, "777                 ", "%-20o", 0777u);
+    PRINTF_TEST(20, "37777777001         ", "%-20o", -0777u);
+    PRINTF_TEST(20, "1234abcd            ", "%-20x", 0x1234abcdu);
+    PRINTF_TEST(20, "edcb5433            ", "%-20x", -0x1234abcdu);
+    PRINTF_TEST(20, "1234ABCD            ", "%-20X", 0x1234abcdu);
+    PRINTF_TEST(20, "EDCB5433            ", "%-20X", -0x1234abcdu);
+    PRINTF_TEST(20, "x                   ", "%-20c", 'x');
+    /* Feldbreite: Padding mit 0 */
+    PRINTF_TEST(20, "00000000000000001024", "%020d", 1024);
+    PRINTF_TEST(20, "-0000000000000001024", "%020d", -1024);
+    PRINTF_TEST(20, "00000000000000001024", "%020i", 1024);
+    PRINTF_TEST(20, "-0000000000000001024", "%020i", -1024);
+    PRINTF_TEST(20, "00000000000000001024", "%020u", 1024u);
+    PRINTF_TEST(20, "00000000004294966272", "%020u", -1024u);
+    PRINTF_TEST(20, "00000000000000000777", "%020o", 0777u);
+    PRINTF_TEST(20, "00000000037777777001", "%020o", -0777u);
+    PRINTF_TEST(20, "0000000000001234abcd", "%020x", 0x1234abcdu);
+    PRINTF_TEST(20, "000000000000edcb5433", "%020x", -0x1234abcdu);
+    PRINTF_TEST(20, "0000000000001234ABCD", "%020X", 0x1234abcdu);
+    PRINTF_TEST(20, "000000000000EDCB5433", "%020X", -0x1234abcdu);
+    /* Feldbreite: Padding und alternative Form */
+    PRINTF_TEST(20, "                0777", "%#20o", 0777u);
+    PRINTF_TEST(20, "        037777777001", "%#20o", -0777u);
+    PRINTF_TEST(20, "          0x1234abcd", "%#20x", 0x1234abcdu);
+    PRINTF_TEST(20, "          0xedcb5433", "%#20x", -0x1234abcdu);
+    PRINTF_TEST(20, "          0X1234ABCD", "%#20X", 0x1234abcdu);
+    PRINTF_TEST(20, "          0XEDCB5433", "%#20X", -0x1234abcdu);
+    PRINTF_TEST(20, "00000000000000000777", "%#020o", 0777u);
+    PRINTF_TEST(20, "00000000037777777001", "%#020o", -0777u);
+    PRINTF_TEST(20, "0x00000000001234abcd", "%#020x", 0x1234abcdu);
+    PRINTF_TEST(20, "0x0000000000edcb5433", "%#020x", -0x1234abcdu);
+    PRINTF_TEST(20, "0X00000000001234ABCD", "%#020X", 0x1234abcdu);
+    PRINTF_TEST(20, "0X0000000000EDCB5433", "%#020X", -0x1234abcdu);
+    /* Feldbreite: - hat Vorrang vor 0 */
+    PRINTF_TEST(20, "Hallo               ", "%0-20s", "Hallo");
+    PRINTF_TEST(20, "1024                ", "%0-20d", 1024);
+    PRINTF_TEST(20, "-1024               ", "%0-20d", -1024);
+    PRINTF_TEST(20, "1024                ", "%0-20i", 1024);
+    PRINTF_TEST(20, "-1024               ", "%0-20i", -1024);
+    PRINTF_TEST(20, "1024                ", "%0-20u", 1024u);
+    PRINTF_TEST(20, "4294966272          ", "%0-20u", -1024u);
+    PRINTF_TEST(20, "777                 ", "%-020o", 0777u);
+    PRINTF_TEST(20, "37777777001         ", "%-020o", -0777u);
+    PRINTF_TEST(20, "1234abcd            ", "%-020x", 0x1234abcdu);
+    PRINTF_TEST(20, "edcb5433            ", "%-020x", -0x1234abcdu);
+    PRINTF_TEST(20, "1234ABCD            ", "%-020X", 0x1234abcdu);
+    PRINTF_TEST(20, "EDCB5433            ", "%-020X", -0x1234abcdu);
+    PRINTF_TEST(20, "x                   ", "%-020c", 'x');
+    /* Feldbreite: Aus Parameter */
+    PRINTF_TEST(20, "               Hallo", "%*s", 20, "Hallo");
+    PRINTF_TEST(20, "                1024", "%*d", 20, 1024);
+    PRINTF_TEST(20, "               -1024", "%*d", 20, -1024);
+    PRINTF_TEST(20, "                1024", "%*i", 20, 1024);
+    PRINTF_TEST(20, "               -1024", "%*i", 20, -1024);
+    PRINTF_TEST(20, "                1024", "%*u", 20, 1024u);
+    PRINTF_TEST(20, "          4294966272", "%*u", 20, -1024u);
+    PRINTF_TEST(20, "                 777", "%*o", 20, 0777u);
+    PRINTF_TEST(20, "         37777777001", "%*o", 20, -0777u);
+    PRINTF_TEST(20, "            1234abcd", "%*x", 20, 0x1234abcdu);
+    PRINTF_TEST(20, "            edcb5433", "%*x", 20, -0x1234abcdu);
+    PRINTF_TEST(20, "            1234ABCD", "%*X", 20, 0x1234abcdu);
+    PRINTF_TEST(20, "            EDCB5433", "%*X", 20, -0x1234abcdu);
+    PRINTF_TEST(20, "                   x", "%*c", 20, 'x');
+    /* Präzision / Mindestanzahl von Ziffern */
+    PRINTF_TEST(12, "Hallo heimur", "%.20s", "Hallo heimur");
+    PRINTF_TEST(20, "00000000000000001024", "%.20d", 1024);
+    PRINTF_TEST(21, "-00000000000000001024", "%.20d", -1024);
+    PRINTF_TEST(20, "00000000000000001024", "%.20i", 1024);
+    PRINTF_TEST(21, "-00000000000000001024", "%.20i", -1024);
+    PRINTF_TEST(20, "00000000000000001024", "%.20u", 1024u);
+    PRINTF_TEST(20, "00000000004294966272", "%.20u", -1024u);
+    PRINTF_TEST(20, "00000000000000000777", "%.20o", 0777u);
+    PRINTF_TEST(20, "00000000037777777001", "%.20o", -0777u);
+    PRINTF_TEST(20, "0000000000001234abcd", "%.20x", 0x1234abcdu);
+    PRINTF_TEST(20, "000000000000edcb5433", "%.20x", -0x1234abcdu);
+    PRINTF_TEST(20, "0000000000001234ABCD", "%.20X", 0x1234abcdu);
+    PRINTF_TEST(20, "000000000000EDCB5433", "%.20X", -0x1234abcdu);
+    /* Feldbreite und Präzision */
+    PRINTF_TEST(20, "               Hallo", "%20.5s", "Hallo heimur");
+    PRINTF_TEST(20, "               01024", "%20.5d", 1024);
+    PRINTF_TEST(20, "              -01024", "%20.5d", -1024);
+    PRINTF_TEST(20, "               01024", "%20.5i", 1024);
+    PRINTF_TEST(20, "              -01024", "%20.5i", -1024);
+    PRINTF_TEST(20, "               01024", "%20.5u", 1024u);
+    PRINTF_TEST(20, "          4294966272", "%20.5u", -1024u);
+    PRINTF_TEST(20, "               00777", "%20.5o", 0777u);
+    PRINTF_TEST(20, "         37777777001", "%20.5o", -0777u);
+    PRINTF_TEST(20, "            1234abcd", "%20.5x", 0x1234abcdu);
+    PRINTF_TEST(20, "          00edcb5433", "%20.10x", -0x1234abcdu);
+    PRINTF_TEST(20, "            1234ABCD", "%20.5X", 0x1234abcdu);
+    PRINTF_TEST(20, "          00EDCB5433", "%20.10X", -0x1234abcdu);
+    /* Präzision: 0 wird ignoriert */
+    PRINTF_TEST(20, "               Hallo", "%020.5s", "Hallo heimur");
+    PRINTF_TEST(20, "               01024", "%020.5d", 1024);
+    PRINTF_TEST(20, "              -01024", "%020.5d", -1024);
+    PRINTF_TEST(20, "               01024", "%020.5i", 1024);
+    PRINTF_TEST(20, "              -01024", "%020.5i", -1024);
+    PRINTF_TEST(20, "               01024", "%020.5u", 1024u);
+    PRINTF_TEST(20, "          4294966272", "%020.5u", -1024u);
+    PRINTF_TEST(20, "               00777", "%020.5o", 0777u);
+    PRINTF_TEST(20, "         37777777001", "%020.5o", -0777u);
+    PRINTF_TEST(20, "            1234abcd", "%020.5x", 0x1234abcdu);
+    PRINTF_TEST(20, "          00edcb5433", "%020.10x", -0x1234abcdu);
+    PRINTF_TEST(20, "            1234ABCD", "%020.5X", 0x1234abcdu);
+    PRINTF_TEST(20, "          00EDCB5433", "%020.10X", -0x1234abcdu);
+    /* Präzision 0 */
+    PRINTF_TEST(0, "", "%.0s", "Hallo heimur");
+    PRINTF_TEST(20, "                    ", "%20.0s", "Hallo heimur");
+    PRINTF_TEST(0, "", "%.s", "Hallo heimur");
+    PRINTF_TEST(20, "                    ", "%20.s", "Hallo heimur");
+    PRINTF_TEST(20, "                1024", "%20.0d", 1024);
+    PRINTF_TEST(20, "               -1024", "%20.d", -1024);
+    PRINTF_TEST(20, "                    ", "%20.d", 0);
+    PRINTF_TEST(20, "                1024", "%20.0i", 1024);
+    PRINTF_TEST(20, "               -1024", "%20.i", -1024);
+    PRINTF_TEST(20, "                    ", "%20.i", 0);
+    PRINTF_TEST(20, "                1024", "%20.u", 1024u);
+    PRINTF_TEST(20, "          4294966272", "%20.0u", -1024u);
+    PRINTF_TEST(20, "                    ", "%20.u", 0u);
+    PRINTF_TEST(20, "                 777", "%20.o", 0777u);
+    PRINTF_TEST(20, "         37777777001", "%20.0o", -0777u);
+    PRINTF_TEST(20, "                    ", "%20.o", 0u);
+    PRINTF_TEST(20, "            1234abcd", "%20.x", 0x1234abcdu);
+    PRINTF_TEST(20, "            edcb5433", "%20.0x", -0x1234abcdu);
+    PRINTF_TEST(20, "                    ", "%20.x", 0u);
+    PRINTF_TEST(20, "            1234ABCD", "%20.X", 0x1234abcdu);
+    PRINTF_TEST(20, "            EDCB5433", "%20.0X", -0x1234abcdu);
+    PRINTF_TEST(20, "                    ", "%20.X", 0u);
+    /* Negative Präzision wird ignoriert */
+    /* XXX glibc tut nicht, was ich erwartet habe, vorerst deaktiviert... */
+    /*
+     * Präzision und Feldbreite aus Parameter.
+     * + hat Vorrang vor <space>, - hat Vorrang vor 0 (das eh ignoriert wird,
+     * weil eine Präzision angegeben ist)
+     */
+    PRINTF_TEST(20, "Hallo               ", "% -0+*.*s", 20, 5, "Hallo heimur");
+    PRINTF_TEST(20, "+01024              ", "% -0+*.*d", 20, 5, 1024);
+    PRINTF_TEST(20, "-01024              ", "% -0+*.*d", 20, 5, -1024);
+    PRINTF_TEST(20, "+01024              ", "% -0+*.*i", 20, 5, 1024);
+    PRINTF_TEST(20, "-01024              ", "% 0-+*.*i", 20, 5, -1024);
+    PRINTF_TEST(20, "01024               ", "% 0-+*.*u", 20, 5, 1024u);
+    PRINTF_TEST(20, "4294966272          ", "% 0-+*.*u", 20, 5, -1024u);
+    PRINTF_TEST(20, "00777               ", "%+ -0*.*o", 20, 5, 0777u);
+    PRINTF_TEST(20, "37777777001         ", "%+ -0*.*o", 20, 5, -0777u);
+    PRINTF_TEST(20, "1234abcd            ", "%+ -0*.*x", 20, 5, 0x1234abcdu);
+    PRINTF_TEST(20, "00edcb5433          ", "%+ -0*.*x", 20, 10, -0x1234abcdu);
+    PRINTF_TEST(20, "1234ABCD            ", "% -+0*.*X", 20, 5, 0x1234abcdu);
+    PRINTF_TEST(20, "00EDCB5433          ", "% -+0*.*X", 20, 10, -0x1234abcdu);
+    }
+/******************************************************************************/
diff --git a/src/pdclib/testing/scanf_testcases.h b/src/pdclib/testing/scanf_testcases.h
new file mode 100644
index 0000000..f9007d6
--- /dev/null
+++ b/src/pdclib/testing/scanf_testcases.h
@@ -0,0 +1,87 @@
+{
+    char buffer[100];
+    int i;
+    unsigned int u;
+    int * p;
+    /* basic: reading of three-char string */
+    SCANF_TEST( 1, "foo", "%3c", buffer );
+    TESTCASE( memcmp( buffer, "foo", 3 ) == 0 );
+#ifndef TEST_CONVERSION_ONLY
+    /* %% for single % */
+    SCANF_TEST( 1, "%x", "%%%c", buffer );
+    TESTCASE( buffer[0] == 'x' );
+    /* * to skip assignment */
+    SCANF_TEST( 1, "3xfoo", "%*dx%3c", buffer );
+    TESTCASE( memcmp( buffer, "foo", 3 ) == 0 );
+#endif
+    /* domain testing on 'int' type */
+    SCANF_TEST( 1, "-" INT_MIN_DEZ_STR, "%d", &i );
+    TESTCASE( i == INT_MIN );
+    SCANF_TEST( 1, INT_MAX_DEZ_STR, "%d", &i );
+    TESTCASE( i == INT_MAX );
+    SCANF_TEST( 1, "-1", "%d", &i );
+    TESTCASE( i == -1 );
+    SCANF_TEST( 1, "0", "%d", &i );
+    TESTCASE( i == 0 );
+    SCANF_TEST( 1, "1", "%d", &i );
+    TESTCASE( i == 1 );
+    SCANF_TEST( 1, "-" INT_MIN_DEZ_STR, "%i", &i );
+    TESTCASE( i == INT_MIN );
+    SCANF_TEST( 1, INT_MAX_DEZ_STR, "%i", &i );
+    TESTCASE( i == INT_MAX );
+    SCANF_TEST( 1, "-1", "%i", &i );
+    TESTCASE( i == -1 );
+    SCANF_TEST( 1, "0", "%i", &i );
+    TESTCASE( i == 0 );
+    SCANF_TEST( 1, "1", "%i", &i );
+    TESTCASE( i == 1 );
+    SCANF_TEST( 1, "0x7" INT_HEXDIG, "%i", &i );
+    TESTCASE( i == INT_MAX );
+    SCANF_TEST( 1, "0x0", "%i", &i );
+    TESTCASE( i == 0 );
+#ifndef TEST_CONVERSION_ONLY
+    SCANF_TEST( 1, "00", "%i%n", &i, &u );
+    TESTCASE( i == 0 );
+    TESTCASE( u == 2 );
+#endif
+    /* domain testing on 'unsigned int' type */
+    SCANF_TEST( 1, UINT_MAX_DEZ_STR, "%u", &u );
+    TESTCASE( u == UINT_MAX );
+    SCANF_TEST( 1, "0", "%u", &u );
+    TESTCASE( u == 0 );
+    SCANF_TEST( 1, "f" INT_HEXDIG, "%x", &u );
+    TESTCASE( u == UINT_MAX );
+    SCANF_TEST( 1, "7" INT_HEXDIG, "%x", &u );
+    TESTCASE( u == INT_MAX );
+    SCANF_TEST( 1, "0", "%o", &u );
+    TESTCASE( u == 0 );
+    SCANF_TEST( 1, INT_OCTDIG, "%o", &u );
+    TESTCASE( u == UINT_MAX );
+    /* testing %c */
+    memset( buffer, '\0', 100 );
+    SCANF_TEST( 1, "x", "%c", buffer );
+    TESTCASE( memcmp( buffer, "x\0", 2 ) == 0 );
+    /* testing %s */
+    memset( buffer, '\0', 100 );
+    SCANF_TEST( 1, "foo bar", "%s", buffer );
+    TESTCASE( memcmp( buffer, "foo\0", 4 ) == 0 );
+#ifndef TEST_CONVERSION_ONLY
+    SCANF_TEST( 2, "foo bar  baz", "%s %s %n", buffer, buffer + 4, &u );
+    TESTCASE( u == 9 );
+    TESTCASE( memcmp( buffer, "foo\0bar\0", 8 ) == 0 );
+#endif
+    /* testing %[ */
+    SCANF_TEST( 1, "abcdefg", "%[cba]", buffer );
+    TESTCASE( memcmp( buffer, "abc\0", 4 ) == 0 );
+    /* testing %p */
+    p = NULL;
+    sprintf( buffer, "%p", p );
+    p = &i;
+    SCANF_TEST( 1, buffer, "%p", &p );
+    TESTCASE( p == NULL );
+    p = &i;
+    sprintf( buffer, "%p", p );
+    p = NULL;
+    SCANF_TEST( 1, buffer, "%p", &p );
+    TESTCASE( p == &i );
+}