xref: /external/valgrind/main/drd/tests/unit_vc.c

/** @brief Unit-test for DRD's vector clock implementation. */


#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "drd/drd_vc.c"


/* Replacements for Valgrind core functionality. */

void* VG_(malloc)(const HChar* cc, SizeT nbytes)
{ return malloc(nbytes); }
void* VG_(realloc)(const HChar* cc, void* p, SizeT size)
{ return realloc(p, size); }
void  VG_(free)(void* p)
{ return free(p); }
void  VG_(assert_fail)(Bool isCore, const HChar* assertion, const HChar* file,
                       Int line, const HChar* function, const HChar* format,
                       ...)
{
  fprintf(stderr,
          "%s:%u: %s%sAssertion `%s' failed.\n",
          file,
          line,
          function ? (char*)function : "",
          function ? ": " : "",
          assertion);
  fflush(stdout);
  fflush(stderr);
  abort();
}

void* VG_(memset)(void *s, Int c, SizeT sz)
{ return memset(s, c, sz); }
void* VG_(memcpy)(void *d, const void *s, SizeT sz)
{ return memcpy(d, s, sz); }
Int VG_(memcmp)(const void* s1, const void* s2, SizeT n)
{ return memcmp(s1, s2, n); }
UInt VG_(printf)(const HChar *format, ...)
{ UInt ret; va_list vargs; va_start(vargs, format); ret = vprintf(format, vargs); va_end(vargs); return ret; }
UInt VG_(snprintf)(HChar* buf, Int size, const HChar *format, ...)
{ UInt ret; va_list vargs; va_start(vargs, format); ret = vsnprintf(buf, size, format, vargs); va_end(vargs); return ret; }
SizeT VG_(strlen)(const HChar* str) { return strlen(str); }
UInt VG_(message)(VgMsgKind kind, const HChar* format, ...)
{ UInt ret; va_list vargs; va_start(vargs, format); ret = vprintf(format, vargs); va_end(vargs); printf("\n"); return ret; }
Bool DRD_(is_suppressed)(const Addr a1, const Addr a2)
{ assert(0); }


/* Actual unit test */

static void vc_unittest(void)
{
  int i;
  char *str;
  VectorClock vc1;
  VCElem vc1elem[] = { { 3, 7 }, { 5, 8 }, };
  VectorClock vc2;
  VCElem vc2elem[] = { { 1, 4 }, { 3, 9 }, };
  VectorClock vc3;
  VCElem vc4elem[] = { { 1, 3 }, { 2, 1 }, };
  VectorClock vc4;
  VCElem vc5elem[] = { { 1, 4 }, };
  VectorClock vc5;

  DRD_(vc_init)(&vc1, vc1elem, sizeof(vc1elem)/sizeof(vc1elem[0]));
  DRD_(vc_init)(&vc2, vc2elem, sizeof(vc2elem)/sizeof(vc2elem[0]));
  DRD_(vc_init)(&vc3, 0, 0);
  DRD_(vc_init)(&vc4, vc4elem, sizeof(vc4elem)/sizeof(vc4elem[0]));
  DRD_(vc_init)(&vc5, vc5elem, sizeof(vc5elem)/sizeof(vc5elem[0]));

  DRD_(vc_combine)(&vc3, &vc1);
  DRD_(vc_combine)(&vc3, &vc2);

  fprintf(stderr, "vc1: %s", (str = DRD_(vc_aprint)(&vc1)));
  free(str);
  fprintf(stderr, "\nvc2: %s", (str = DRD_(vc_aprint)(&vc2)));
  free(str);
  fprintf(stderr, "\nvc3: %s", (str = DRD_(vc_aprint)(&vc3)));
  free(str);
  fprintf(stderr, "\n");
  fprintf(stderr, "vc_lte(vc1, vc2) = %d, vc_lte(vc1, vc3) = %d,"
          " vc_lte(vc2, vc3) = %d\nvc_lte(",
          DRD_(vc_lte)(&vc1, &vc2), DRD_(vc_lte)(&vc1, &vc3),
          DRD_(vc_lte)(&vc2, &vc3));
  fprintf(stderr, "%s", (str = DRD_(vc_aprint)(&vc4)));
  free(str);
  fprintf(stderr, ", ");
  fprintf(stderr, "%s", (str = DRD_(vc_aprint)(&vc5)));
  free(str);
  fprintf(stderr, ") = %d sw %d\n",
          DRD_(vc_lte)(&vc4, &vc5), DRD_(vc_lte)(&vc5, &vc4));

  for (i = 0; i < 64; i++)
    DRD_(vc_reserve)(&vc1, i);
  for (i = 64; i > 0; i--)
    DRD_(vc_reserve)(&vc1, i);

  DRD_(vc_cleanup)(&vc1);
  DRD_(vc_cleanup)(&vc2);
  DRD_(vc_cleanup)(&vc3);
}

int main(int argc, char** argv)
{
  vc_unittest();
  return 0;
}