mars-nwe/tests/nwnss/xstring/test_nwnss_xstring.c

#include "library/xString.h"
#include "library/string.h"

#include <stdint.h>
#include <stdio.h>
#include <stddef.h>

/* libNSS.imp exports these legacy symbols even though the modern NSS
 * xString.h leaves the prototypes commented out.  Keep the imported header
 * original and declare them locally for ABI coverage.
 */
extern int LB_memcmp(const void *s1, const void *s2, size_t n);
extern size_t LB_strlen(const char *s);

#define CHECK(expr) \
  do { \
    if (!(expr)) { \
      fprintf(stderr, "CHECK failed at %s:%d: %s\n", __FILE__, __LINE__, #expr); \
      return 1; \
    } \
  } while (0)

static int
raw_memcmp(const void *left, const void *right, size_t count)
{
  const unsigned char *l = (const unsigned char *)left;
  const unsigned char *r = (const unsigned char *)right;

  for (size_t i = 0; i < count; ++i) {
    if (l[i] != r[i]) {
      return (int)l[i] - (int)r[i];
    }
  }

  return 0;
}

static int
raw_strcmp(const char *left, const char *right)
{
  while (*left != '\0' && *left == *right) {
    ++left;
    ++right;
  }

  return (unsigned char)*left - (unsigned char)*right;
}

static void
raw_memset(void *buffer, int value, size_t count)
{
  unsigned char *bytes = (unsigned char *)buffer;

  for (size_t i = 0; i < count; ++i) {
    bytes[i] = (unsigned char)value;
  }
}

static void
raw_strcpy(char *dest, const char *src)
{
  while ((*dest++ = *src++) != '\0') {
    /* copy */
  }
}

int main(void)
{
  char buffer[64];
  char second[64];
  char overlap[16] = "abcdef";
  char unchanged[4] = "abc";
  uint32_t words[3] = {0, 0, 0};
  unsigned char guid[16] = {
    0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
    0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
  };
  unsigned char parsed_guid[16];
  char hex[33];

  CHECK(LB_memset(buffer, 'A', 4) == buffer);
  CHECK(raw_memcmp(buffer, "AAAA", 4) == 0);
  CHECK(LB_memcpy(second, buffer, 4) == second);
  CHECK(raw_memcmp(second, "AAAA", 4) == 0);
  CHECK(LB_memchr(second, 'A', 4) == second);
  CHECK(LB_memchr(second, 'Z', 4) == NULL);
  CHECK(LB_memcmp(second, "AAAA", 4) == 0);
  CHECK(LB_memcmp(second, "AAAB", 4) < 0);
  CHECK(LB_memcmp(second, "AAA@", 4) > 0);

  CHECK(LB_memmove(overlap + 2, overlap, 4) == overlap + 2);
  CHECK(raw_memcmp(overlap, "ababcd", 6) == 0);
  LB_bzero(overlap, 3);
  CHECK(overlap[0] == '\0' && overlap[1] == '\0' && overlap[2] == '\0');

  CHECK(LB_memlset(words, 0x11223344L, 3) == words);
  CHECK(words[0] == 0x11223344U);
  CHECK(words[1] == 0x11223344U);
  CHECK(words[2] == 0x11223344U);

  CHECK(LB_strcpy(buffer, "Mars") == buffer);
  CHECK(raw_strcmp(buffer, "Mars") == 0);
  CHECK(LB_strcat(buffer, "NWE") == buffer);
  CHECK(raw_strcmp(buffer, "MarsNWE") == 0);
  CHECK(LB_strcmp(buffer, "MarsNWE") == 0);
  CHECK(LB_strncmp(buffer, "MarsXXX", 4) == 0);
  CHECK(LB_strchr(buffer, 'N') == buffer + 4);
  CHECK(LB_strrchr(buffer, 's') == buffer + 3);
  CHECK(LB_strstr(buffer, "NWE") == buffer + 4);
  CHECK(LB_strlen(buffer) == 7);
  CHECK(LB_strlen("") == 0);

  raw_memset(buffer, 'x', sizeof(buffer));
  CHECK(LB_strmcpy(buffer, "abcdef", 4) == buffer);
  CHECK(raw_strcmp(buffer, "abc") == 0);
  CHECK(buffer[4] == 'x');
  CHECK(LB_strmcpy(unchanged, "z", 0) == unchanged);
  CHECK(raw_strcmp(unchanged, "abc") == 0);
  CHECK(LB_strncpy(buffer, "hi", 5) == buffer);
  CHECK(buffer[0] == 'h' && buffer[1] == 'i' && buffer[2] == '\0' && buffer[3] == '\0');

  CHECK(LB_stricmp("Mars", "mArS") == 0);
  CHECK(LB_stricmp("abc", "ABD") < 0);
  CHECK(LB_stricmp("ABZ", "aby") > 0);
  CHECK(LB_strnicmp("NetWare", "net", 3) == 0);
  CHECK(LB_strnicmp("abc", "abd", 2) == 0);
  CHECK(LB_strnicmp("abc", "abd", 3) < 0);
  CHECK(LB_memicmp("AbCd", "aBcD", 4) == 0);
  CHECK(LB_memicmp("AbCd", "aBcE", 4) < 0);

  raw_strcpy(buffer, "Mars");
  CHECK(LB_strlwr(buffer) == buffer);
  CHECK(raw_strcmp(buffer, "mars") == 0);
  CHECK(LB_strupr(buffer) == buffer);
  CHECK(raw_strcmp(buffer, "MARS") == 0);
  CHECK(LB_strrev(buffer) == buffer);
  CHECK(raw_strcmp(buffer, "SRAM") == 0);
  CHECK(LB_strset(buffer, 'x') == buffer);
  CHECK(raw_strcmp(buffer, "xxxx") == 0);
  buffer[0] = '\0';
  CHECK(LB_strrev(buffer) == buffer);
  CHECK(raw_strcmp(buffer, "") == 0);

  CMovFast(second, (void *)"12345", 6);
  CHECK(raw_strcmp(second, "12345") == 0);
  CMovFastCache(second + 1, second, 4);
  CHECK(raw_memcmp(second, "11234", 5) == 0);

  CHECK(isPattern("plain") == 0);
  CHECK(isPattern("pl?in") == 1);
  CHECK(isPattern("*") == 1);
  CHECK(isPattern("[abc]") == 1);
  CHECK(isMatch("m*e", "MarsNWE") == 1);
  CHECK(isMatch("m?s", "Mars") == 0);
  CHECK(isMatch("m??s", "Mars") == 1);
  CHECK(isMatch("nwe", "Mars") == 0);

  CHECK(dotcmp("VOL.FILE", "vol.file") == 0);
  CHECK(dotcmp("VOL.FILE", "vol.other") == 0);
  CHECK(dotcmp("ABC.DEF", "ABD.DEF") < 0);
  CHECK(dotcmp("ABZ.DEF", "ABY.DEF") > 0);
  CHECK(dotlen("VOL.FILE") == 3);
  CHECK(dotlen("VOLUME") == 6);

  CHECK(guid2hex(guid, hex) == 0);
  CHECK(raw_strcmp(hex, "00112233445566778899aabbccddeeff") == 0);
  raw_memset(parsed_guid, 0, sizeof(parsed_guid));
  CHECK(hex2guid(hex, parsed_guid) == 0);
  CHECK(raw_memcmp(parsed_guid, guid, sizeof(guid)) == 0);
  CHECK(hex2guid("{00112233-4455-6677-8899-aabbccddeeff}", parsed_guid) == 0);
  CHECK(raw_memcmp(parsed_guid, guid, sizeof(guid)) == 0);
  CHECK(hex2guid("001122", parsed_guid) != 0);
  CHECK(hex2guid("00112233445566778899aabbccddeefg", parsed_guid) != 0);

  return 0;
}