raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update to allocator

Browse source
This commit is contained in:
Maix0 2024-05-23 15:18:28 +02:00
parent b96c5e1e66
commit c461fe3323
10 changed files with 469 additions and 14 deletions
Download patch file Download diff file Expand all files Collapse all files

196
stdme/test/realloc.c Normal file
View file

@ -0,0 +1,196 @@
/* Copyright (C) 2013-2024 Free Software Foundation, Inc.
This file is part of the GNU C Library.
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
<https://www.gnu.org/licenses/>. */
#include <errno.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aq/melloc_interal.h"
#include "./redef_alloc.h"
void FAIL_EXIT1(char *fmt, ...)
{
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
exit(1);
}
static int do_test(int argc, char **argv)
{
(void)(argv);
(void)(argv);
void *p;
unsigned char *p1, *p2, *p3;
unsigned char *c;
int save, i, ok;
errno = 0;
p1 = realloc(NULL, 50);
memset(p1, 0x10, 50);
for (i = 0; i < 50; i++)
{
if (p1[i] != 0x10)
FAIL_EXIT1("memset didn't set (p[%i] = %#02x)\n", i, p1[i]);
}
p2 = malloc(50);
p3 = realloc(p1, 150);
if (p1 == p3)
FAIL_EXIT1("P1 == P2 \n");
for (i = 0; i < 50; i++)
{
if (p3[i] != 0x10)
FAIL_EXIT1("realloc didn't preserve after move (p3[%i] = %#02x)\n", i, p3[i]);
}
// /* realloc (NULL, ...) behaves similarly to malloc (C89). */
// p = realloc(NULL, -1);
// save = errno;
//
// if (p != NULL)
// FAIL_EXIT1("realloc (NULL, -1) succeeded.\n");
//
// /* errno should be set to ENOMEM on failure (POSIX). */
// if (p == NULL && save != ENOMEM)
// FAIL_EXIT1("errno is not set correctly\n");
//
// errno = 0;
//
// /* realloc (NULL, ...) behaves similarly to malloc (C89). */
// p = realloc(NULL, 10);
// save = errno;
//
// if (p == NULL)
// FAIL_EXIT1("realloc (NULL, 10) failed.\n");
//
// free(p);
//
// p = calloc(20, 1);
// if (p == NULL)
// FAIL_EXIT1("calloc (20, 1) failed.\n");
//
// /* Check increasing size preserves contents (C89). */
// p = realloc(p, 200);
// if (p == NULL)
// FAIL_EXIT1("realloc (p, 200) failed.\n");
//
// c = p;
// ok = 1;
//
// for (i = 0; i < 20; i++)
// {
// if (c[i] != 0)
// ok = 0;
// }
//
// if (ok == 0)
// FAIL_EXIT1("first 20 bytes were not cleared\n");
//
// free(p);
//
// p = realloc(NULL, 100);
// if (p == NULL)
// FAIL_EXIT1("realloc (NULL, 100) failed.\n");
//
// memset(p, 0xff, 100);
//
// /* Check decreasing size preserves contents (C89). */
// p = realloc(p, 16);
// if (p == NULL)
// FAIL_EXIT1("realloc (p, 16) failed.\n");
//
// c = p;
// ok = 1;
//
// for (i = 0; i < 16; i++)
// {
// if (c[i] != 0xff)
// ok = 0;
// }
//
// if (ok == 0)
// FAIL_EXIT1("first 16 bytes were not correct\n");
//
// /* Check failed realloc leaves original untouched (C89). */
// c = realloc(p, -1);
// if (c != NULL)
// FAIL_EXIT1("realloc (p, -1) succeeded.\n");
//
// c = p;
// ok = 1;
//
// for (i = 0; i < 16; i++)
// {
// if (c[i] != 0xff)
// ok = 0;
// }
//
// if (ok == 0)
// FAIL_EXIT1("first 16 bytes were not correct after failed realloc\n");
//
// /* realloc (p, 0) frees p (C89) and returns NULL (glibc). */
// p = realloc(p, 0);
// if (p != NULL)
// FAIL_EXIT1("realloc (p, 0) returned non-NULL.\n");
//
// /* realloc (NULL, 0) acts like malloc (0) (glibc). */
// p = realloc(NULL, 0);
// if (p == NULL)
// FAIL_EXIT1("realloc (NULL, 0) returned NULL.\n");
//
// free(p);
//
// printf("WTF\n");
//
// /* Smoke test to make sure that allocations do not move if they have
// enough
// space to expand in the chunk. */
// for (size_t sz = 3; sz < 256 * 1024; sz += 2048)
// {
// p = realloc(NULL, sz);
// if (p == NULL)
// FAIL_EXIT1("realloc (NULL, %zu) returned NULL.\n", sz);
// size_t newsz = ((t_chunk *)((void *)(p) - sizeof(t_chunk)))->size;
// printf("size: %zu, usable size: %zu, extra: %zu\n", sz, newsz,
// newsz - sz);
// uintptr_t oldp = (uintptr_t)p;
// void *new_p = realloc(p, newsz);
// if ((uintptr_t)new_p != oldp)
// FAIL_EXIT1(
// "Expanding (%zu bytes) to usable size (%zu) moved block\n", sz,
// newsz);
// free(new_p);
//
// /* We encountered a large enough extra size at least once. */
// if (newsz - sz > 1024)
// break;
// }
return 0;
}
#define TEST_FUNCTION do_test()
#include "./test-skeleton.c"