libc

HomepageMembersTimelineGalleryDownloadBug reports
Browse Download file Permalink
/* $Id$ */
/* Copyright (c) 2014-2018 Pierre Pronchery <khorben@defora.org> */
/* This file is part of DeforaOS System libc */
/* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
#include <unistd.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <stdlib.h>
extern char ** environ;
/* stdlib */
/* private */
/* prototypes */
static int _error(char const * progname, char const * message, int ret);
static int _arc4random(char const * progname);
static int _calloc(char const * progname);
static int _environ(char const * program);
static int _mkstemp(char const * progname);
static int _mktemp(char const * progname);
static int _strtold(char const * progname, char const * str,
long double expected);
static int _strtol(char const * progname);
static int _strtoll(char const * progname);
static int _strtoul(char const * progname);
static int _strtoull(char const * progname);
/* functions */
/* arc4random */
static int _arc4random(char const * progname)
{
uint32_t res[4];
size_t i;
printf("%s: Testing arc4random()\n", progname);
/* XXX not deterministic */
for(i = 0; i < sizeof(res) / sizeof(*res); i++)
res[i] = arc4random();
for(i = 0; i < sizeof(res) / sizeof(*res); i++)
printf("%u. 0x%08x\n", i + 1, res[i]);
/* XXX false negatives are unlikely but possible */
if(res[0] == res[1] && res[0] == res[2] && res[0] == res[3])
return 1;
return 0;
}
/* calloc */
static int _calloc(char const * progname)
{
int * p;
size_t i;
const size_t cnt = 16;
printf("%s: Testing calloc()\n", progname);
if(calloc(SIZE_MAX, 2) != NULL || calloc(2, SIZE_MAX) != NULL)
{
printf("calloc() failed to detect overflow\n");
return 1;
}
if((p = calloc(sizeof(int), cnt)) == NULL)
{
printf("calloc() failed to allocate memory\n");
return 1;
}
for(i = 0; i < cnt; i++)
if(p[i] != 0)
{
printf("calloc() failed to clear memory\n");
return 1;
}
free(p);
return 0;
}
/* environ */
static int _environ(char const * progname)
{
char ** e;
printf("%s: Testing environ\n", progname);
for(e = environ; *e != NULL; e++)
printf("%s: %s\n", progname, *e);
return 0;
}
/* error */
static int _error(char const * progname, char const * message, int ret)
{
fputs(progname, stderr);
fputs(": ", stderr);
perror(message);
return ret;
}
/* mkstemp */
static int _mkstemp(char const * progname)
{
int ret = 0;
char buf[] = "/tmp/stdlib.XXXXXX";
int fd;
printf("%s: Testing mkstemp()\n", progname);
if((fd = mkstemp(buf)) < 0)
return _error(progname, "mkstemp", 1);
if(unlink(buf) != 0)
ret = _error(progname, "unlink", 1);
if(close(fd) != 0)
ret = _error(progname, "close", 1);
return ret;
}
/* mktemp */
static int _mktemp(char const * progname)
{
char buf[] = "/tmp/stdlib.XXXXXX";
printf("%s: Testing mktemp()\n", progname);
return (mktemp(buf) == buf) ? 0 : _error(progname, "mktemp", 1);
}
/* realloc */
static int _realloc(char const * progname)
{
size_t i;
char * p = NULL;
char * q;
printf("%s: Testing realloc()\n", progname);
for(i = 0; i < 65536; i++)
{
if((q = realloc(p, arc4random() % 65536)) == NULL)
{
fprintf(stderr, "%s: %s: %s (%zu)\n", progname,
"realloc", strerror(errno), i);
free(p);
return -1;
}
p = q;
}
free(p);
return 0;
}
/* strtold */
static int _strtold(char const * progname, char const * str,
long double expected)
{
int ret = 0;
long double ld;
double d;
float f;
char * p;
printf("%s: Testing strtold(\"%s\", %Lf)\n", progname, str, expected);
ld = strtold(str, &p);
if(ld != expected || *p != '\0')
{
fprintf(stderr, "%s: %s: Obtained %Lf (expected: %Lf)\n",
progname, "strtold", ld, expected);
ret = 1;
}
printf("%s: Testing strtod(\"%s\", %Lf)\n", progname, str, expected);
d = strtod(str, &p);
if(d != (double)expected || *p != '\0')
{
fprintf(stderr, "%s: %s: Obtained %f (expected: %f)\n",
progname, "strtod", d, expected);
ret = 1;
}
printf("%s: Testing strtof(\"%s\", %Lf)\n", progname, str, expected);
f = strtof(str, &p);
if(f != (float)expected || *p != '\0')
{
fprintf(stderr, "%s: %s: Obtained %f (expected: %f)\n",
progname, "strtof", f, expected);
ret = 1;
}
return ret;
}
/* strtol */
static int _strtol(char const * progname)
{
char * p;
char const spaces[] = " ";
long l;
unsigned long lu;
char buf[32];
/* spaces */
errno = 0;
strtol(spaces, &p, 0);
if(p != spaces || errno != ERANGE)
{
fprintf(stderr, "%s: %s: Conversion error (spaces)\n", progname,
"strtol");
return 1;
}
/* -LONG_MAX - 1 */
lu = (unsigned long)LONG_MAX + 1;
snprintf(buf, sizeof(buf), "-%lu", lu);
errno = 0;
l = strtol(buf, &p, 10);
if(errno != 0)
{
fprintf(stderr, "%s: %s: Conversion error (-LONG_MAX - 1)\n",
progname, "strtol");
return 1;
}
/* -LONG_MAX - 2 */
lu = (unsigned long)LONG_MAX + 2;
snprintf(buf, sizeof(buf), "-%lu", lu);
errno = 0;
strtol(buf, &p, 10);
if(errno != ERANGE)
{
fprintf(stderr, "%s: %s: Conversion error (-LONG_MAX - 2)\n",
progname, "strtol");
return 1;
}
/* invalid input */
l = strtol("invalid", &p, 0);
if(l != 0 || errno != EINVAL)
{
fprintf(stderr, "%s: %s: Conversion error (invalid input)\n",
progname, "strtol");
return 1;
}
return 0;
}
/* strtoll */
static int _strtoll(char const * progname)
{
char * p;
char const spaces[] = " ";
long long ll;
unsigned long long llu;
char buf[32];
/* spaces */
errno = 0;
strtoll(spaces, &p, 0);
if(p != spaces || errno != ERANGE)
{
fprintf(stderr, "%s: %s: Conversion error (spaces)\n", progname,
"strtol");
return 1;
}
/* -LLONG_MAX - 1 */
llu = (unsigned long long)LLONG_MAX + 1;
snprintf(buf, sizeof(buf), "-%llu", llu);
errno = 0;
ll = strtoll(buf, &p, 10);
if(errno != 0)
{
fprintf(stderr, "%s: %s: Conversion error (-LLONG_MAX - 1)\n",
progname, "strtoll");
return 1;
}
/* -LLONG_MAX - 2 */
llu = (unsigned long)LLONG_MAX + 2;
snprintf(buf, sizeof(buf), "-%llu", llu);
errno = 0;
strtoll(buf, &p, 10);
if(errno != ERANGE)
{
fprintf(stderr, "%s: %s: Conversion error (-LLONG_MAX - 2)\n",
progname, "strtoll");
return 1;
}
/* invalid input */
ll = strtoll("invalid", &p, 0);
if(ll != 0 || errno != EINVAL)
{
fprintf(stderr, "%s: %s: Conversion error (invalid input)\n",
progname, "strtoll");
return 1;
}
return 0;
}
/* strtoul */
static int _strtoul(char const * progname)
{
char * p;
char const spaces[] = " ";
char buf[32];
/* spaces */
errno = 0;
strtoul(spaces, &p, 0);
if(p != spaces || errno != ERANGE)
{
fprintf(stderr, "%s: %s: Conversion error (spaces)\n", progname,
"strtoul");
return 1;
}
/* ULONG_MAX */
snprintf(buf, sizeof(buf), "%lu", ULONG_MAX);
errno = 0;
strtoul(buf, &p, 10);
if(errno != 0 || *p != '\0')
{
fprintf(stderr, "%s: %s: Conversion error (ULONG_MAX)\n",
progname, "strtoul");
return 1;
}
return 0;
}
/* strtoull */
static int _strtoull(char const * progname)
{
char * p;
char const spaces[] = " ";
char buf[32];
/* spaces */
errno = 0;
strtoull(spaces, &p, 0);
if(p != spaces || errno != ERANGE)
{
fprintf(stderr, "%s: %s: Conversion error (spaces)\n", progname,
"strtoul");
return 1;
}
/* ULLONG_MAX */
snprintf(buf, sizeof(buf), "%llu", ULLONG_MAX);
errno = 0;
strtoull(buf, &p, 10);
if(errno != 0 || *p != '\0')
{
fprintf(stderr, "%s: %s: Conversion error (ULLONG_MAX)\n",
progname, "strtoul");
return 1;
}
return 0;
}
/* public */
/* functions */
/* main */
int main(int argc, char * argv[])
{
int ret = 0;
(void) argc;
ret += _arc4random(argv[0]);
ret += _calloc(argv[0]);
ret += _environ(argv[0]);
ret += _mkstemp(argv[0]);
ret += _mktemp(argv[0]);
ret += _realloc(argv[0]);
ret += _strtold(argv[0], "0.0", 0.0);
ret += _strtold(argv[0], " 0.1", 0.1);
ret += _strtold(argv[0], " 1.0", 1.0);
ret += _strtold(argv[0], "+1.1", 1.1);
ret += _strtold(argv[0], "+1.01", 1.01);
ret += _strtold(argv[0], "-1.1", -1.1);
ret += _strtold(argv[0], "-1.01", -1.01);
ret += _strtol(argv[0]);
ret += _strtoul(argv[0]);
ret += _strtoll(argv[0]);
ret += _strtoull(argv[0]);
return (ret == 0) ? 0 : 2;
}