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 int
  30 main (void)
  31 {
  32         unsigned char *random_mem = (unsigned char *)malloc (POOL_SIZE);
  33         unsigned char *reference = (unsigned char *)malloc (POOL_SIZE);
  34         unsigned char *playground = (unsigned char *)malloc (POOL_SIZE);
  35         long *long_random_mem;
  36         int i, offset, size, src_offset, dest_offset;
  37
  38         srandom (time (NULL));
  39
  40         /* init random memory */
  41         long_random_mem = (long*)random_mem;
  42         for (i = 0; i < POOL_SIZE / sizeof (long); ++i)
  43                 long_random_mem [i] = random ();
  44
  45         /* test bzero */
  46         for (offset = 0; offset <= BZERO_OFFSETS; ++offset) {
  47                 for (size = 0; size <= BZERO_SIZES; ++size) {
  48                         memcpy (reference, random_mem, POOL_SIZE);
  49                         memcpy (playground, random_mem, POOL_SIZE);
  50
  51                         memset (reference + START_OFFSET + offset, 0, size);
  52                         mono_gc_bzero_atomic (playground + START_OFFSET + offset, size);
  53
  54                         assert (!memcmp (reference, playground, POOL_SIZE));
  55                 }
  56         }
  57
  58         /* test memmove */
  59         for (src_offset = -MEMMOVE_SRC_OFFSETS; src_offset <= MEMMOVE_SRC_OFFSETS; ++src_offset) {
  60                 for (dest_offset = -MEMMOVE_DEST_OFFSETS; dest_offset <= MEMMOVE_DEST_OFFSETS; ++dest_offset) {
  61                         for (size = 0; size <= MEMMOVE_SIZES; ++size) {
  62                                 /* overlapping */
  63                                 memcpy (reference, random_mem, POOL_SIZE);
  64                                 memcpy (playground, random_mem, POOL_SIZE);
  65
  66                                 memmove (reference + START_OFFSET + dest_offset, reference + START_OFFSET + src_offset, size);
  67                                 mono_gc_memmove_atomic (playground + START_OFFSET + dest_offset, playground + START_OFFSET + src_offset, size);
  68
  69                                 assert (!memcmp (reference, playground, POOL_SIZE));
  70
  71                                 /* non-overlapping with dest < src */
  72                                 memcpy (reference, random_mem, POOL_SIZE);
  73                                 memcpy (playground, random_mem, POOL_SIZE);
  74
  75                                 memmove (reference + START_OFFSET + dest_offset, reference + MEMMOVE_NONOVERLAP_START + src_offset, size);
  76                                 mono_gc_memmove_atomic (playground + START_OFFSET + dest_offset, playground + MEMMOVE_NONOVERLAP_START + src_offset, size);
  77
  78                                 assert (!memcmp (reference, playground, POOL_SIZE));
  79
  80                                 /* non-overlapping with dest > src */
  81                                 memcpy (reference, random_mem, POOL_SIZE);
  82                                 memcpy (playground, random_mem, POOL_SIZE);
  83
  84                                 memmove (reference + MEMMOVE_NONOVERLAP_START + dest_offset, reference + START_OFFSET + src_offset, size);
  85                                 mono_gc_memmove_atomic (playground + MEMMOVE_NONOVERLAP_START + dest_offset, playground + START_OFFSET + src_offset, size);
  86
  87                                 assert (!memcmp (reference, playground, POOL_SIZE));
  88                         }
  89                 }
  90         }
  91
  92         return 0;
  93 }