/* Test the functions defined in byteorder.h.

 *

 * Written by Zack Weinberg <zackw at panix.com> in 2017.

 *

 * No copyright is claimed, and the software is hereby placed in the public

 * domain.  In case this attempt to disclaim copyright and place the software

 * in the public domain is deemed null and void, then the software is

 * Copyright (c) 2017 Zack Weinberg and it is hereby released to the

 * general public under the following terms:

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted.

 *

 * There's ABSOLUTELY NO WARRANTY, express or implied.

 */

#include "crypt-port.h"

#include "byteorder.h"

#include <inttypes.h>

#include <stdio.h>

struct test_32

{

  uint32_t val;

  unsigned char bytes[4];

};

struct test_64

{

  uint64_t val;

  unsigned char bytes[8];

};

#define Z(x) ((unsigned int)(unsigned char)(x)) /* zero extend char */

static int

test_le32 (void)

{

  static const struct test_32 cases[] =

  {

    { 0x00000000, "\x00\x00\x00\x00" },

    { 0xFF000000, "\x00\x00\x00\xFF" },

    { 0x00FF0000, "\x00\x00\xFF\x00" },

    { 0x0000FF00, "\x00\xFF\x00\x00" },

    { 0x000000FF, "\xFF\x00\x00\x00" },

    { 0x01234567, "\x67\x45\x23\x01" },

  };

  size_t n_cases = ARRAY_SIZE (cases);

  size_t i;

  uint32_t v;

  unsigned char x[4];

  int status = 0;

  for (i = 0; i < n_cases; i++)

    {

      v = le32_to_cpu (cases[i].bytes);

      if (v != cases[i].val)

        {

          printf ("FAIL: le32_to_cpu: %02x %02x %02x %02x -> "

                  "%08"PRIx32" != %08"PRIx32"\n",

                  Z(cases[i].bytes[0]), Z(cases[i].bytes[1]),

                  Z(cases[i].bytes[2]), Z(cases[i].bytes[3]),

                  v, cases[i].val);

          status = 1;

        }

      cpu_to_le32 (x, cases[i].val);

      if (memcmp (x, cases[i].bytes, 4))

        {

          printf ("FAIL: cpu_to_le32: %08"PRIx32" -> "

                  "%02x %02x %02x %02x != %02x %02x %02x %02x\n",

                  cases[i].val,

                  Z(x[0]), Z(x[1]), Z(x[2]), Z(x[3]),

                  Z(cases[i].bytes[0]), Z(cases[i].bytes[1]),

                  Z(cases[i].bytes[2]), Z(cases[i].bytes[3]));

          status = 1;

        }

    }

  return status;

}

static int

test_be32 (void)

{

  static const struct test_32 cases[] =

  {

    { 0x00000000, "\x00\x00\x00\x00" },

    { 0xFF000000, "\xFF\x00\x00\x00" },

    { 0x00FF0000, "\x00\xFF\x00\x00" },

    { 0x0000FF00, "\x00\x00\xFF\x00" },

    { 0x000000FF, "\x00\x00\x00\xFF" },

    { 0x01234567, "\x01\x23\x45\x67" },

  };

  size_t n_cases = ARRAY_SIZE (cases);

  size_t i;

  uint32_t v;

  unsigned char x[4];

  int status = 0;

  for (i = 0; i < n_cases; i++)

    {

      v = be32_to_cpu (cases[i].bytes);

      if (v != cases[i].val)

        {

          printf ("FAIL: be32_to_cpu: %02x %02x %02x %02x -> "

                  "%08"PRIx32" != %08"PRIx32"\n",

                  Z(cases[i].bytes[0]), Z(cases[i].bytes[1]),

                  Z(cases[i].bytes[2]), Z(cases[i].bytes[3]),

                  v, cases[i].val);

          status = 1;

        }

      cpu_to_be32 (x, cases[i].val);

      if (memcmp (x, cases[i].bytes, 4))

        {

          printf ("FAIL: cpu_to_be32: %08"PRIx32" -> "

                  "%02x %02x %02x %02x != %02x %02x %02x %02x\n",

                  cases[i].val,

                  Z(x[0]), Z(x[1]), Z(x[2]), Z(x[3]),

                  Z(cases[i].bytes[0]), Z(cases[i].bytes[1]),

                  Z(cases[i].bytes[2]), Z(cases[i].bytes[3]));

          status = 1;

        }

    }

  return status;

}

static int

test_le64 (void)

{

  static const struct test_64 cases[] =

  {

    { 0x0000000000000000ull, "\x00\x00\x00\x00\x00\x00\x00\x00" },

    { 0x00000000000000FFull, "\xFF\x00\x00\x00\x00\x00\x00\x00" },

    { 0x000000000000FF00ull, "\x00\xFF\x00\x00\x00\x00\x00\x00" },

    { 0x0000000000FF0000ull, "\x00\x00\xFF\x00\x00\x00\x00\x00" },

    { 0x00000000FF000000ull, "\x00\x00\x00\xFF\x00\x00\x00\x00" },

    { 0x000000FF00000000ull, "\x00\x00\x00\x00\xFF\x00\x00\x00" },

    { 0x0000FF0000000000ull, "\x00\x00\x00\x00\x00\xFF\x00\x00" },

    { 0x00FF000000000000ull, "\x00\x00\x00\x00\x00\x00\xFF\x00" },

    { 0xFF00000000000000ull, "\x00\x00\x00\x00\x00\x00\x00\xFF" },

    { 0x0123456789ABCDEFull, "\xEF\xCD\xAB\x89\x67\x45\x23\x01" },

  };

  size_t n_cases = ARRAY_SIZE (cases);

  size_t i;

  uint64_t v;

  unsigned char x[8];

  int status = 0;

  for (i = 0; i < n_cases; i++)

    {

      v = le64_to_cpu (cases[i].bytes);

      if (v != cases[i].val)

        {

          printf ("FAIL: le64_to_cpu: %02x%02x %02x%02x %02x%02x %02x%02x "

                  "-> %016"PRIx64" != %016"PRIx64"\n",

                  Z(cases[i].bytes[0]), Z(cases[i].bytes[1]),

                  Z(cases[i].bytes[2]), Z(cases[i].bytes[3]),

                  Z(cases[i].bytes[4]), Z(cases[i].bytes[5]),

                  Z(cases[i].bytes[6]), Z(cases[i].bytes[7]),

                  v, cases[i].val);

          status = 1;

        }

      cpu_to_le64 (x, cases[i].val);

      if (memcmp (x, cases[i].bytes, 8))

        {

          printf ("FAIL: cpu_to_le64: %016"PRIx64" -> "

                  "%02x%02x %02x%02x %02x%02x %02x%02x != "

                  "%02x%02x %02x%02x %02x%02x %02x%02x\n",

                  cases[i].val,

                  Z(x[0]), Z(x[1]), Z(x[2]), Z(x[3]),

                  Z(x[4]), Z(x[5]), Z(x[6]), Z(x[7]),

                  Z(cases[i].bytes[0]), Z(cases[i].bytes[1]),

                  Z(cases[i].bytes[2]), Z(cases[i].bytes[3]),

                  Z(cases[i].bytes[4]), Z(cases[i].bytes[5]),

                  Z(cases[i].bytes[6]), Z(cases[i].bytes[7]));

          status = 1;

        }

    }

  return status;

}

static int

test_be64 (void)

{

  static const struct test_64 cases[] =

  {

    { 0x0000000000000000ull, "\x00\x00\x00\x00\x00\x00\x00\x00" },

    { 0x00000000000000FFull, "\x00\x00\x00\x00\x00\x00\x00\xFF" },

    { 0x000000000000FF00ull, "\x00\x00\x00\x00\x00\x00\xFF\x00" },

    { 0x0000000000FF0000ull, "\x00\x00\x00\x00\x00\xFF\x00\x00" },

    { 0x00000000FF000000ull, "\x00\x00\x00\x00\xFF\x00\x00\x00" },

    { 0x000000FF00000000ull, "\x00\x00\x00\xFF\x00\x00\x00\x00" },

    { 0x0000FF0000000000ull, "\x00\x00\xFF\x00\x00\x00\x00\x00" },

    { 0x00FF000000000000ull, "\x00\xFF\x00\x00\x00\x00\x00\x00" },

    { 0xFF00000000000000ull, "\xFF\x00\x00\x00\x00\x00\x00\x00" },

    { 0x0123456789ABCDEFull, "\x01\x23\x45\x67\x89\xAB\xCD\xEF" },

  };

  size_t n_cases = ARRAY_SIZE (cases);

  size_t i;

  uint64_t v;

  unsigned char x[8];

  int status = 0;

  for (i = 0; i < n_cases; i++)

    {

      v = be64_to_cpu (cases[i].bytes);

      if (v != cases[i].val)

        {

          printf ("FAIL: be64_to_cpu: %02x%02x %02x%02x %02x%02x %02x%02x "

                  "-> %016"PRIx64" != %016"PRIx64"\n",

                  Z(cases[i].bytes[0]), Z(cases[i].bytes[1]),

                  Z(cases[i].bytes[2]), Z(cases[i].bytes[3]),

                  Z(cases[i].bytes[4]), Z(cases[i].bytes[5]),

                  Z(cases[i].bytes[6]), Z(cases[i].bytes[7]),

                  v, cases[i].val);

          status = 1;

        }

      cpu_to_be64 (x, cases[i].val);

      if (memcmp (x, cases[i].bytes, 8))

        {

          printf ("FAIL: cpu_to_be64: %016"PRIx64" -> "

                  "%02x%02x %02x%02x %02x%02x %02x%02x != "

                  "%02x%02x %02x%02x %02x%02x %02x%02x\n",

                  cases[i].val,

                  Z(x[0]), Z(x[1]), Z(x[2]), Z(x[3]),

                  Z(x[4]), Z(x[5]), Z(x[6]), Z(x[7]),

                  Z(cases[i].bytes[0]), Z(cases[i].bytes[1]),

                  Z(cases[i].bytes[2]), Z(cases[i].bytes[3]),

                  Z(cases[i].bytes[4]), Z(cases[i].bytes[5]),

                  Z(cases[i].bytes[6]), Z(cases[i].bytes[7]));

          status = 1;

        }

    }

  return status;

}

int

main (void)

{

  int status = 0;

  status |= test_le32 ();

  status |= test_be32 ();

  status |= test_le64 ();

  status |= test_be64 ();

  return status;

}