mono/unit-tests/test-memfuncs.c

   1 /*
   2  * test-sgen-qsort.c: Unit test for our own bzero/memmove.
   3  *
   4  * Copyright (C) 2013 Xamarin Inc
   5  *
   6  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   7  */
   8
   9 #include "config.h"
  10
  11 #include "utils/memfuncs.h"
  12
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <time.h>
  16 #include <assert.h>
  17
  18 #define POOL_SIZE       2048
  19 #define START_OFFSET    128
  20
  21 #define BZERO_OFFSETS   64
  22 #define BZERO_SIZES     256
  23
  24 #define MEMMOVE_SRC_OFFSETS             32
  25 #define MEMMOVE_DEST_OFFSETS            32
  26 #define MEMMOVE_SIZES                   256
  27 #define MEMMOVE_NONOVERLAP_START        1024
  28
  29 #ifdef __cplusplus
  30 extern "C"
  31 #endif
  32 int
  33 test_memfuncs_main (void);
  34
  35 int
  36 test_memfuncs_main (void)
  37 {
  38         unsigned char *random_mem = (unsigned char *)malloc (POOL_SIZE);
  39         unsigned char *reference = (unsigned char *)malloc (POOL_SIZE);
  40         unsigned char *playground = (unsigned char *)malloc (POOL_SIZE);
  41         long *long_random_mem;
  42         int i, offset, size, src_offset, dest_offset;
  43
  44         srandom (time (NULL));
  45
  46         /* init random memory */
  47         long_random_mem = (long*)random_mem;
  48         for (i = 0; i < POOL_SIZE / sizeof (long); ++i)
  49                 long_random_mem [i] = random ();
  50
  51         /* test bzero */
  52         for (offset = 0; offset <= BZERO_OFFSETS; ++offset) {
  53                 for (size = 0; size <= BZERO_SIZES; ++size) {
  54                         memcpy (reference, random_mem, POOL_SIZE);
  55                         memcpy (playground, random_mem, POOL_SIZE);
  56
  57                         memset (reference + START_OFFSET + offset, 0, size);
  58                         mono_gc_bzero_atomic (playground + START_OFFSET + offset, size);
  59
  60                         assert (!memcmp (reference, playground, POOL_SIZE));
  61                 }
  62         }
  63
  64         /* test memmove */
  65         for (src_offset = -MEMMOVE_SRC_OFFSETS; src_offset <= MEMMOVE_SRC_OFFSETS; ++src_offset) {
  66                 for (dest_offset = -MEMMOVE_DEST_OFFSETS; dest_offset <= MEMMOVE_DEST_OFFSETS; ++dest_offset) {
  67                         for (size = 0; size <= MEMMOVE_SIZES; ++size) {
  68                                 /* overlapping */
  69                                 memcpy (reference, random_mem, POOL_SIZE);
  70                                 memcpy (playground, random_mem, POOL_SIZE);
  71
  72                                 memmove (reference + START_OFFSET + dest_offset, reference + START_OFFSET + src_offset, size);
  73                                 mono_gc_memmove_atomic (playground + START_OFFSET + dest_offset, playground + START_OFFSET + src_offset, size);
  74
  75                                 assert (!memcmp (reference, playground, POOL_SIZE));
  76
  77                                 /* non-overlapping with dest < src */
  78                                 memcpy (reference, random_mem, POOL_SIZE);
  79                                 memcpy (playground, random_mem, POOL_SIZE);
  80
  81                                 memmove (reference + START_OFFSET + dest_offset, reference + MEMMOVE_NONOVERLAP_START + src_offset, size);
  82                                 mono_gc_memmove_atomic (playground + START_OFFSET + dest_offset, playground + MEMMOVE_NONOVERLAP_START + src_offset, size);
  83
  84                                 assert (!memcmp (reference, playground, POOL_SIZE));
  85
  86                                 /* non-overlapping with dest > src */
  87                                 memcpy (reference, random_mem, POOL_SIZE);
  88                                 memcpy (playground, random_mem, POOL_SIZE);
  89
  90                                 memmove (reference + MEMMOVE_NONOVERLAP_START + dest_offset, reference + START_OFFSET + src_offset, size);
  91                                 mono_gc_memmove_atomic (playground + MEMMOVE_NONOVERLAP_START + dest_offset, playground + START_OFFSET + src_offset, size);
  92
  93                                 assert (!memcmp (reference, playground, POOL_SIZE));
  94                         }
  95                 }
  96         }
  97
  98         free (random_mem);
  99         free (reference);
 100         free (playground);
 101
 102         return 0;
 103 }