Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /* Copyright (C) 2000, 2002 Free Software Foundation, Inc.
  2.    This file is part of the GNU C Library.
  3.    Contributed by Ulrich Drepper <drepper@redhat.com>.
  4.  
  5.    The GNU C Library is free software; you can redistribute it and/or
  6.    modify it under the terms of the GNU Lesser General Public
  7.    License as published by the Free Software Foundation; either
  8.    version 2.1 of the License, or (at your option) any later version.
  9.  
  10.    The GNU C Library is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.    Lesser General Public License for more details.
  14.  
  15.    You should have received a copy of the GNU Lesser General Public
  16.    License along with the GNU C Library; if not, write to the Free
  17.    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18.    02111-1307 USA.  */
  19.  
  20. #include <errno.h>
  21. #include <error.h>
  22. #include <limits.h>
  23. #include <malloc.h>
  24. #include <stdlib.h>
  25. #include <stdio.h>
  26.  
  27.  
  28. /* Number of samples per size.  */
  29. #define N 50000
  30.  
  31.  
  32. static void
  33. fixed_test (int size)
  34. {
  35.   char *ptrs[N];
  36.   int i;
  37.  
  38.   for (i = 0; i < N; ++i)
  39.     {
  40.       int j;
  41.  
  42.       ptrs[i] = (char *) calloc (1, size);
  43.  
  44.       if (ptrs[i] == NULL)
  45.         break;
  46.  
  47.       for (j = 0; j < size; ++j)
  48.         {
  49.           if (ptrs[i][j] != '\0')
  50.             error (EXIT_FAILURE, 0,
  51.                    "byte not cleared (size %d, element %d, byte %d)",
  52.                    size, i, j);
  53.           ptrs[i][j] = '\xff';
  54.         }
  55.     }
  56.  
  57.   while (i-- > 0)
  58.     free (ptrs[i]);
  59. }
  60.  
  61.  
  62. static void
  63. random_test (void)
  64. {
  65.   char *ptrs[N];
  66.   int i;
  67.  
  68.   for (i = 0; i < N; ++i)
  69.     {
  70.       int j;
  71.       int n = 1 + random () % 10;
  72.       int elem = 1 + random () % 100;
  73.       int size = n * elem;
  74.  
  75.       ptrs[i] = (char *) calloc (n, elem);
  76.  
  77.       if (ptrs[i] == NULL)
  78.         break;
  79.  
  80.       for (j = 0; j < size; ++j)
  81.         {
  82.           if (ptrs[i][j] != '\0')
  83.             error (EXIT_FAILURE, 0,
  84.                    "byte not cleared (size %d, element %d, byte %d)",
  85.                    size, i, j);
  86.           ptrs[i][j] = '\xff';
  87.         }
  88.     }
  89.  
  90.   while (i-- > 0)
  91.     free (ptrs[i]);
  92. }
  93.  
  94.  
  95. static void
  96. null_test (void)
  97. {
  98.   /* If the size is 0 the result is implementation defined.  Just make
  99.      sure the program doesn't crash.  */
  100.   calloc (0, 0);
  101.   calloc (0, UINT_MAX);
  102.   calloc (UINT_MAX, 0);
  103.   calloc (0, ~((size_t) 0));
  104.   calloc (~((size_t) 0), 0);
  105. }
  106.  
  107.  
  108. int
  109. main (void)
  110. {
  111.   /* We are allocating blocks with `calloc' and check whether every
  112.      block is completely cleared.  We first try this for some fixed
  113.      times and then with random size.  */
  114.   fixed_test (15);
  115.   fixed_test (5);
  116.   fixed_test (17);
  117.   fixed_test (6);
  118.   fixed_test (31);
  119.   fixed_test (96);
  120.  
  121.   random_test ();
  122.  
  123.   null_test ();
  124.  
  125.   return 0;
  126. }
  127.