[thirdparty/glibc.git] / malloc / tst-calloc.c

/* Copyright (C) 2000-2017 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@redhat.com>.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#include <errno.h>
#include <error.h>
#include <limits.h>
#include <malloc.h>
#include <stdlib.h>
#include <stdio.h>


/* Number of samples per size.  */
#define N 50000


static void
fixed_test (int size)
{
  char *ptrs[N];
  int i;

  for (i = 0; i < N; ++i)
    {
      int j;

      ptrs[i] = (char *) calloc (1, size);

      if (ptrs[i] == NULL)
	break;

      for (j = 0; j < size; ++j)
	{
	  if (ptrs[i][j] != '\0')
	    error (EXIT_FAILURE, 0,
		   "byte not cleared (size %d, element %d, byte %d)",
		   size, i, j);
	  ptrs[i][j] = '\xff';
	}
    }

  while (i-- > 0)
    free (ptrs[i]);
}


static void
random_test (void)
{
  char *ptrs[N];
  int i;

  for (i = 0; i < N; ++i)
    {
      int j;
      int n = 1 + random () % 10;
      int elem = 1 + random () % 100;
      int size = n * elem;

      ptrs[i] = (char *) calloc (n, elem);

      if (ptrs[i] == NULL)
	break;

      for (j = 0; j < size; ++j)
	{
	  if (ptrs[i][j] != '\0')
	    error (EXIT_FAILURE, 0,
		   "byte not cleared (size %d, element %d, byte %d)",
		   size, i, j);
	  ptrs[i][j] = '\xff';
	}
    }

  while (i-- > 0)
    free (ptrs[i]);
}


static void
null_test (void)
{
  /* If the size is 0 the result is implementation defined.  Just make
     sure the program doesn't crash.  */
  calloc (0, 0);
  calloc (0, UINT_MAX);
  calloc (UINT_MAX, 0);
  calloc (0, ~((size_t) 0));
  calloc (~((size_t) 0), 0);
}


static int
do_test (void)
{
  /* We are allocating blocks with `calloc' and check whether every
     block is completely cleared.  We first try this for some fixed
     times and then with random size.  */
  fixed_test (15);
  fixed_test (5);
  fixed_test (17);
  fixed_test (6);
  fixed_test (31);
  fixed_test (96);

  random_test ();

  null_test ();

  return 0;
}

#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"
Commit	Line	Data
bfff8b1b	1	/* Copyright (C) 2000-2017 Free Software Foundation, Inc.
aa780bab UD	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
41bdb6e2 AJ	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.
aa780bab UD	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
41bdb6e2	13	Lesser General Public License for more details.
aa780bab	14
41bdb6e2	15	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	16	License along with the GNU C Library; if not, see
59ba27a6 PE	17	<http://www.gnu.org/licenses/>. */
aa780bab UD	18
	19	#include <errno.h>
	20	#include <error.h>
a2e62fb1	21	#include <limits.h>
aa780bab UD	22	#include <malloc.h>
	23	#include <stdlib.h>
	24	#include <stdio.h>
	25
	26
	27	/* Number of samples per size. */
	28	#define N 50000
	29
	30
	31	static void
	32	fixed_test (int size)
	33	{
	34	char *ptrs[N];
	35	int i;
	36
	37	for (i = 0; i < N; ++i)
	38	{
	39	int j;
	40
	41	ptrs[i] = (char *) calloc (1, size);
	42
	43	if (ptrs[i] == NULL)
	44	break;
	45
	46	for (j = 0; j < size; ++j)
	47	{
	48	if (ptrs[i][j] != '\0')
	49	error (EXIT_FAILURE, 0,
	50	"byte not cleared (size %d, element %d, byte %d)",
	51	size, i, j);
	52	ptrs[i][j] = '\xff';
	53	}
	54	}
	55
	56	while (i-- > 0)
	57	free (ptrs[i]);
	58	}
	59
	60
	61	static void
	62	random_test (void)
	63	{
	64	char *ptrs[N];
	65	int i;
	66
	67	for (i = 0; i < N; ++i)
	68	{
	69	int j;
	70	int n = 1 + random () % 10;
	71	int elem = 1 + random () % 100;
	72	int size = n * elem;
	73
	74	ptrs[i] = (char *) calloc (n, elem);
	75
	76	if (ptrs[i] == NULL)
	77	break;
	78
	79	for (j = 0; j < size; ++j)
	80	{
	81	if (ptrs[i][j] != '\0')
	82	error (EXIT_FAILURE, 0,
	83	"byte not cleared (size %d, element %d, byte %d)",
	84	size, i, j);
	85	ptrs[i][j] = '\xff';
86	}
87	}
88
89	while (i-- > 0)
90	free (ptrs[i]);
91	}
92
93
a2e62fb1 UD	94	static void
	95	null_test (void)
	96	{
	97	/* If the size is 0 the result is implementation defined. Just make
	98	sure the program doesn't crash. */
	99	calloc (0, 0);
	100	calloc (0, UINT_MAX);
	101	calloc (UINT_MAX, 0);
	102	calloc (0, ~((size_t) 0));
	103	calloc (~((size_t) 0), 0);
	104	}
	105
	106
29955b5d AS	107	static int
29955b5d AS	108	do_test (void)
aa780bab UD	109	{
	110	/* We are allocating blocks with `calloc' and check whether every
	111	block is completely cleared. We first try this for some fixed
	112	times and then with random size. */
	113	fixed_test (15);
	114	fixed_test (5);
	115	fixed_test (17);
	116	fixed_test (6);
	117	fixed_test (31);
	118	fixed_test (96);
	119
	120	random_test ();
	121
a2e62fb1 UD	122	null_test ();
a2e62fb1 UD	123
aa780bab UD	124	return 0;
aa780bab UD	125	}
29955b5d AS	126
	127	#define TEST_FUNCTION do_test ()
	128	#include "../test-skeleton.c"