Version 0.4.00.4.0

1 files changed, 128 insertions, 0 deletions

diff --git a/tests/tst-registers.c b/tests/tst-registers.c
new file mode 100644
index 0000000..c8b1c99
--- /dev/null
+++ b/tests/tst-registers.c
@@ -0,0 +1,128 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+
+#include <libmcpu.h>
+
+
+static int failures = 0;
+
+#define CHECK(cond,msg) \
+  do { \
+    if( !(cond) ) \
+    { \
+      fprintf( stderr, "FAIL: %s\n", (msg) ); \
+      ++failures; \
+    } \
+  } while( 0 )
+
+
+struct width_test
+{
+  unsigned int bits;
+  __mpu_size_t bytes;
+};
+
+
+int
+main( void )
+{
+  static const struct width_test widths[] =
+  {
+    {     8,    1 },
+    {    16,    2 },
+    {    32,    4 },
+    {    64,    8 },
+    {   128,   16 },
+    {   256,   32 },
+    {   512,   64 },
+    {  1024,  128 },
+    {  2048,  256 },
+    {  4096,  512 },
+    {  8192, 1024 },
+    { 16384, 2048 },
+    { 32768, 4096 },
+    { 65536, 8192 }
+  };
+
+  __mpu_size_t i;
+
+  __cpu_init();
+
+  CHECK( CPU_REGISTERS_MEM_SIZE_IN_UNITS == 524288,
+         "512 KiB register file size" );
+  CHECK( CPU_REGISTER_ADDRESS_MAX == 0x0007ffffU,
+         "register address maximum" );
+  CHECK( CPU_REGISTER_MIN_BITS == 8,
+         "minimum register width" );
+  CHECK( CPU_REGISTER_MAX_BITS == 65536,
+         "maximum register width" );
+
+  for( i = 0; i < sizeof( widths ) / sizeof( widths[0] ); ++i )
+  {
+    __mpu_uint32_t last;
+
+    CHECK( __cpu_reg_size( widths[i].bits ) == widths[i].bytes,
+           "register width size" );
+
+    CHECK( __cpu_reg_valid( widths[i].bits, 0 ) == 1,
+           "register at address zero" );
+
+    CHECK( __cpu_reg_ptr( widths[i].bits, 0 ) == __cpu_registers,
+           "register pointer at address zero" );
+
+    last = (__mpu_uint32_t)(CPU_REGISTERS_MEM_SIZE_IN_UNITS - widths[i].bytes);
+
+    CHECK( __cpu_reg_valid( widths[i].bits, last ) == 1,
+           "last naturally aligned register" );
+
+    CHECK( __cpu_reg_ptr( widths[i].bits, last ) == &__cpu_registers[last],
+           "last register pointer" );
+
+    if( widths[i].bytes > 1 )
+    {
+      CHECK( __cpu_reg_valid( widths[i].bits, last + 1 ) == 0,
+             "natural alignment check" );
+      CHECK( __cpu_reg_ptr( widths[i].bits, last + 1 ) == 0,
+             "unaligned register pointer" );
+    }
+  }
+
+  CHECK( __cpu_reg_size( 0 ) == 0, "zero register width" );
+  CHECK( __cpu_reg_size( 7 ) == 0, "unsupported 7-bit register width" );
+  CHECK( __cpu_reg_size( 24 ) == 0, "unsupported 24-bit register width" );
+  CHECK( __cpu_reg_size( 131072 ) == 0, "register width above 65536" );
+
+  CHECK( __cpu_reg_valid( 8, CPU_REGISTERS_MEM_SIZE_IN_UNITS - 1 ) == 1,
+         "last byte is a valid r8" );
+  CHECK( __cpu_reg_valid( 8, CPU_REGISTERS_MEM_SIZE_IN_UNITS ) == 0,
+         "address one byte beyond register file" );
+  CHECK( __cpu_reg_ptr( 8, CPU_REGISTERS_MEM_SIZE_IN_UNITS ) == 0,
+         "pointer beyond register file" );
+
+  CHECK( __cpu_reg_valid( 32, 12 ) == 1,
+         "r32 naturally aligned address" );
+  CHECK( __cpu_reg_valid( 32, 13 ) == 0,
+         "r32 unaligned address" );
+
+  CHECK( __cpu_reg_valid( 65536, 0x0007e000U ) == 1,
+         "last r65536 region" );
+  CHECK( __cpu_reg_valid( 65536, 0x0007e001U ) == 0,
+         "unaligned r65536 region" );
+  CHECK( __cpu_reg_valid( 65536, 0x00080000U ) == 0,
+         "r65536 beyond register file" );
+
+  if( failures != 0 )
+  {
+    fprintf( stderr, "libcpu register regression: %d failure(s)\n", failures );
+    return( 1 );
+  }
+
+  printf( "libcpu 0.0.3 register width/alignment/bounds regression: PASS\n" );
+  printf( "register widths: r8 ... r65536\n" );
+  printf( "register address range: 0x00000 ... 0x7ffff\n" );
+
+  return( 0 );
+}