Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-29 10:35:28 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/modules/rostests/winetests/msvcrt/heap.c

517 lines
19 KiB
C
Raw Blame History

/*
* Unit test suite for memory functions
*
* Copyright 2003 Dimitrie O. Paun
*
* This 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.
*
* This 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 this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <stdlib.h>
#include <malloc.h>
#include <errno.h>
#include "wine/test.h"
#ifdef __REACTOS__
#if defined(__GNUC__) && __GNUC__ >= 7
#pragma GCC diagnostic ignored "-Walloc-size-larger-than=9223372036854775807"
#endif
#endif
static void (__cdecl *p_aligned_free)(void*) = NULL;
static void * (__cdecl *p_aligned_malloc)(size_t,size_t) = NULL;
static void * (__cdecl *p_aligned_offset_malloc)(size_t,size_t,size_t) = NULL;
static void * (__cdecl *p_aligned_realloc)(void*,size_t,size_t) = NULL;
static void * (__cdecl *p_aligned_offset_realloc)(void*,size_t,size_t,size_t) = NULL;
static void test_aligned_malloc(unsigned int size, unsigned int alignment)
{
void *mem;
mem = p_aligned_malloc(size, alignment);
if ((alignment & (alignment - 1)) == 0)
ok(mem != NULL, "_aligned_malloc(%d, %d) failed\n", size, alignment);
else
ok(mem == NULL, "_aligned_malloc(%d, %d) should have failed\n", size, alignment);
if (mem)
{
ok(((DWORD_PTR)mem & (alignment ? alignment - 1 : 0)) == 0,
"_aligned_malloc(%d, %d) not aligned: %p\n", size, alignment, mem);
if (winetest_debug > 1)
{
void *saved;
saved = *(void **)((DWORD_PTR)((char *)mem - sizeof(void *)) & ~(sizeof(void *) - 1));
trace("_aligned_malloc(%3d, %3d) returns %p, saved = %p\n", size, alignment, mem, saved );
}
p_aligned_free(mem);
}
else
ok(errno == EINVAL, "_aligned_malloc(%d, %d) errno: %d != %d\n", size, alignment, errno, EINVAL);
}
static void test_aligned_offset_malloc(unsigned int size, unsigned int alignment, unsigned int offset)
{
void *mem;
mem = p_aligned_offset_malloc(size, alignment, offset);
if ((alignment & (alignment - 1)) == 0)
if (offset < size)
ok(mem != NULL, "_aligned_offset_malloc(%d, %d, %d) failed\n", size, alignment, offset);
else
ok(errno == EINVAL, "_aligned_offset_malloc(%d, %d, %d) errno: %d != %d\n", size, alignment, offset, errno, EINVAL);
else
ok(mem == NULL, "_aligned_offset_malloc(%d, %d, %d) should have failed\n", size, alignment, offset);
if (mem)
{
ok(((DWORD_PTR)((char *)mem + offset) & (alignment ? alignment - 1 : 0)) == 0,
"_aligned_offset_malloc(%d, %d, %d) not aligned: %p\n", size, alignment, offset, mem);
if (winetest_debug > 1)
{
void *saved;
saved = *(void **)((DWORD_PTR)((char *)mem - sizeof(void *)) & ~(sizeof(void *) - 1));
trace("_aligned_offset_malloc(%3d, %3d, %3d) returns %p, saved = %p\n",
size, alignment, offset, mem, saved);
}
p_aligned_free(mem);
}
else
ok(errno == EINVAL, "_aligned_offset_malloc(%d, %d, %d) errno: %d != %d\n", size, alignment, offset, errno, EINVAL);
}
static void test_aligned_realloc(unsigned int size1, unsigned int size2, unsigned int alignment)
{
void *mem, *mem1, *mem2;
mem = p_aligned_malloc(size1, alignment);
if ((alignment & (alignment - 1)) == 0)
ok(mem != NULL, "_aligned_malloc(%d, %d) failed\n", size1, alignment);
else
ok(mem == NULL, "_aligned_malloc(%d, %d) should have failed\n", size1, alignment);
if (mem)
{
mem1 = malloc(size1);
if (mem1)
{
unsigned int i;
for (i = 0; i < size1; i++)
((char *)mem)[i] = i + 1;
memcpy(mem1, mem, size1);
}
ok(((DWORD_PTR)mem & (alignment ? alignment - 1 : 0)) == 0,
"_aligned_malloc(%d, %d) not aligned: %p\n", size1, alignment, mem);
if (winetest_debug > 1)
{
void *saved;
saved = *(void **)((DWORD_PTR)((char *)mem - sizeof(void *)) & ~(sizeof(void *) - 1));
trace("_aligned_malloc(%3d, %3d) returns %p, saved = %p\n", size1, alignment, mem, saved);
}
mem2 = p_aligned_realloc(mem, size2, alignment);
ok(mem2 != NULL, "_aligned_realloc(%p, %d, %d) failed\n", mem, size2, alignment);
if (mem2)
{
ok(((DWORD_PTR)mem2 & (alignment ? alignment - 1 : 0)) == 0,
"_aligned_realloc(%p, %d, %d) not aligned: %p\n", mem, size2, alignment, mem2);
if (winetest_debug > 1)
{
void *saved;
saved = *(void **)((DWORD_PTR)((char *)mem2 - sizeof(void *)) & ~(sizeof(void *) - 1));
trace("_aligned_realloc(%p, %3d, %3d) returns %p, saved = %p\n",
mem, size2, alignment, mem2, saved);
}
if (mem1)
{
ok(memcmp(mem2, mem1, min(size1, size2))==0, "_aligned_realloc(%p, %d, %d) has different data\n", mem, size2, alignment);
if (memcmp(mem2, mem1, min(size1, size2)) && winetest_debug > 1)
{
unsigned int i;
for (i = 0; i < min(size1, size2); i++)
{
if (((char *)mem2)[i] != ((char *)mem1)[i])
trace("%d: %02x != %02x\n", i, ((char *)mem2)[i] & 0xff, ((char *)mem1)[i] & 0xff);
}
}
}
p_aligned_free(mem2);
} else {
ok(errno == EINVAL, "_aligned_realloc(%p, %d, %d) errno: %d != %d\n", mem, size2, alignment, errno, EINVAL);
p_aligned_free(mem);
}
free(mem1);
}
else
ok(errno == EINVAL, "_aligned_malloc(%d, %d) errno: %d != %d\n", size1, alignment, errno, EINVAL);
}
static void test_aligned_offset_realloc(unsigned int size1, unsigned int size2,
unsigned int alignment, unsigned int offset)
{
void *mem, *mem1, *mem2;
mem = p_aligned_offset_malloc(size1, alignment, offset);
if ((alignment & (alignment - 1)) == 0)
ok(mem != NULL, "_aligned_offset_malloc(%d, %d, %d) failed\n", size1, alignment, offset);
else
ok(mem == NULL, "_aligned_offset_malloc(%d, %d, %d) should have failed\n", size1, alignment, offset);
if (mem)
{
mem1 = malloc(size1);
if (mem1)
{
unsigned int i;
for (i = 0; i < size1; i++)
((char *)mem)[i] = i + 1;
memcpy(mem1, mem, size1);
}
ok(((DWORD_PTR)((char *)mem + offset) & (alignment ? alignment - 1 : 0)) == 0,
"_aligned_offset_malloc(%d, %d, %d) not aligned: %p\n", size1, alignment, offset, mem);
if (winetest_debug > 1)
{
void *saved;
saved = *(void **)((DWORD_PTR)((char *)mem - sizeof(void *)) & ~(sizeof(void *) - 1));
trace("_aligned_offset_malloc(%3d, %3d, %3d) returns %p, saved = %p\n",
size1, alignment, offset, mem, saved);
}
mem2 = p_aligned_offset_realloc(mem, size2, alignment, offset);
ok(mem2 != NULL, "_aligned_offset_realloc(%p, %d, %d, %d) failed\n", mem, size2, alignment, offset);
if (mem2)
{
ok(((DWORD_PTR)((char *)mem + offset) & (alignment ? alignment - 1 : 0)) == 0,
"_aligned_offset_realloc(%p, %d, %d, %d) not aligned: %p\n", mem, size2, alignment, offset, mem2);
if (winetest_debug > 1)
{
void *saved;
saved = *(void **)((DWORD_PTR)((char *)mem2 - sizeof(void *)) & ~(sizeof(void *) - 1));
trace("_aligned_offset_realloc(%p, %3d, %3d, %3d) returns %p, saved = %p\n",
mem, size2, alignment, offset, mem2, saved);
}
if (mem1)
{
ok(memcmp(mem2, mem1, min(size1, size2))==0, "_aligned_offset_realloc(%p, %d, %d, %d) has different data\n", mem, size2, alignment, offset);
if (memcmp(mem2, mem1, min(size1, size2)) && winetest_debug > 1)
{
unsigned int i;
for (i = 0; i < min(size1, size2); i++)
{
if (((char *)mem2)[i] != ((char *)mem1)[i])
trace("%d: %02x != %02x\n", i, ((char *)mem2)[i] & 0xff, ((char *)mem1)[i] & 0xff);
}
}
}
p_aligned_free(mem2);
} else {
ok(errno == EINVAL, "_aligned_offset_realloc(%p, %d, %d, %d) errno: %d != %d\n", mem, size2, alignment, offset, errno, EINVAL);
p_aligned_free(mem);
}
free(mem1);
}
else
ok(errno == EINVAL, "_aligned_offset_malloc(%d, %d) errno: %d != %d\n", size1, alignment, errno, EINVAL);
}
static void test_aligned(void)
{
HMODULE msvcrt = GetModuleHandleA("msvcrt.dll");
if (msvcrt == NULL)
return;
p_aligned_free = (void*)GetProcAddress(msvcrt, "_aligned_free");
p_aligned_malloc = (void*)GetProcAddress(msvcrt, "_aligned_malloc");
p_aligned_offset_malloc = (void*)GetProcAddress(msvcrt, "_aligned_offset_malloc");
p_aligned_realloc = (void*)GetProcAddress(msvcrt, "_aligned_realloc");
p_aligned_offset_realloc = (void*)GetProcAddress(msvcrt, "_aligned_offset_realloc");
if (!p_aligned_free || !p_aligned_malloc || !p_aligned_offset_malloc || !p_aligned_realloc || !p_aligned_offset_realloc)
{
skip("aligned memory tests skipped\n");
return;
}
test_aligned_malloc(256, 0);
test_aligned_malloc(256, 1);
test_aligned_malloc(256, 2);
test_aligned_malloc(256, 3);
test_aligned_malloc(256, 4);
test_aligned_malloc(256, 8);
test_aligned_malloc(256, 16);
test_aligned_malloc(256, 32);
test_aligned_malloc(256, 64);
test_aligned_malloc(256, 127);
test_aligned_malloc(256, 128);
test_aligned_offset_malloc(256, 0, 0);
test_aligned_offset_malloc(256, 1, 0);
test_aligned_offset_malloc(256, 2, 0);
test_aligned_offset_malloc(256, 3, 0);
test_aligned_offset_malloc(256, 4, 0);
test_aligned_offset_malloc(256, 8, 0);
test_aligned_offset_malloc(256, 16, 0);
test_aligned_offset_malloc(256, 32, 0);
test_aligned_offset_malloc(256, 64, 0);
test_aligned_offset_malloc(256, 127, 0);
test_aligned_offset_malloc(256, 128, 0);
test_aligned_offset_malloc(256, 0, 4);
test_aligned_offset_malloc(256, 1, 4);
test_aligned_offset_malloc(256, 2, 4);
test_aligned_offset_malloc(256, 3, 4);
test_aligned_offset_malloc(256, 4, 4);
test_aligned_offset_malloc(256, 8, 4);
test_aligned_offset_malloc(256, 16, 4);
test_aligned_offset_malloc(256, 32, 4);
test_aligned_offset_malloc(256, 64, 4);
test_aligned_offset_malloc(256, 127, 4);
test_aligned_offset_malloc(256, 128, 4);
test_aligned_offset_malloc(256, 8, 7);
test_aligned_offset_malloc(256, 8, 9);
test_aligned_offset_malloc(256, 8, 16);
test_aligned_offset_malloc(256, 8, 17);
test_aligned_offset_malloc(256, 8, 254);
test_aligned_offset_malloc(256, 8, 255);
test_aligned_offset_malloc(256, 8, 256);
test_aligned_offset_malloc(256, 8, 512);
test_aligned_realloc(256, 512, 0);
test_aligned_realloc(256, 128, 0);
test_aligned_realloc(256, 512, 4);
test_aligned_realloc(256, 128, 4);
test_aligned_realloc(256, 512, 8);
test_aligned_realloc(256, 128, 8);
test_aligned_realloc(256, 512, 16);
test_aligned_realloc(256, 128, 16);
test_aligned_realloc(256, 512, 32);
test_aligned_realloc(256, 128, 32);
test_aligned_realloc(256, 512, 64);
test_aligned_realloc(256, 128, 64);
test_aligned_offset_realloc(256, 512, 0, 0);
test_aligned_offset_realloc(256, 128, 0, 0);
test_aligned_offset_realloc(256, 512, 4, 0);
test_aligned_offset_realloc(256, 128, 4, 0);
test_aligned_offset_realloc(256, 512, 8, 0);
test_aligned_offset_realloc(256, 128, 8, 0);
test_aligned_offset_realloc(256, 512, 16, 0);
test_aligned_offset_realloc(256, 128, 16, 0);
test_aligned_offset_realloc(256, 512, 32, 0);
test_aligned_offset_realloc(256, 128, 32, 0);
test_aligned_offset_realloc(256, 512, 64, 0);
test_aligned_offset_realloc(256, 128, 64, 0);
test_aligned_offset_realloc(256, 512, 0, 4);
test_aligned_offset_realloc(256, 128, 0, 4);
test_aligned_offset_realloc(256, 512, 4, 4);
test_aligned_offset_realloc(256, 128, 4, 4);
test_aligned_offset_realloc(256, 512, 8, 4);
test_aligned_offset_realloc(256, 128, 8, 4);
test_aligned_offset_realloc(256, 512, 16, 4);
test_aligned_offset_realloc(256, 128, 16, 4);
test_aligned_offset_realloc(256, 512, 32, 4);
test_aligned_offset_realloc(256, 128, 32, 4);
test_aligned_offset_realloc(256, 512, 64, 4);
test_aligned_offset_realloc(256, 128, 64, 4);
test_aligned_offset_realloc(256, 512, 0, 8);
test_aligned_offset_realloc(256, 128, 0, 8);
test_aligned_offset_realloc(256, 512, 4, 8);
test_aligned_offset_realloc(256, 128, 4, 8);
test_aligned_offset_realloc(256, 512, 8, 8);
test_aligned_offset_realloc(256, 128, 8, 8);
test_aligned_offset_realloc(256, 512, 16, 8);
test_aligned_offset_realloc(256, 128, 16, 8);
test_aligned_offset_realloc(256, 512, 32, 8);
test_aligned_offset_realloc(256, 128, 32, 8);
test_aligned_offset_realloc(256, 512, 64, 8);
test_aligned_offset_realloc(256, 128, 64, 8);
test_aligned_offset_realloc(256, 512, 0, 16);
test_aligned_offset_realloc(256, 128, 0, 16);
test_aligned_offset_realloc(256, 512, 4, 16);
test_aligned_offset_realloc(256, 128, 4, 16);
test_aligned_offset_realloc(256, 512, 8, 16);
test_aligned_offset_realloc(256, 128, 8, 16);
test_aligned_offset_realloc(256, 512, 16, 16);
test_aligned_offset_realloc(256, 128, 16, 16);
test_aligned_offset_realloc(256, 512, 32, 16);
test_aligned_offset_realloc(256, 128, 32, 16);
test_aligned_offset_realloc(256, 512, 64, 16);
test_aligned_offset_realloc(256, 128, 64, 16);
test_aligned_offset_realloc(256, 512, 0, 32);
test_aligned_offset_realloc(256, 128, 0, 32);
test_aligned_offset_realloc(256, 512, 4, 32);
test_aligned_offset_realloc(256, 128, 4, 32);
test_aligned_offset_realloc(256, 512, 8, 32);
test_aligned_offset_realloc(256, 128, 8, 32);
test_aligned_offset_realloc(256, 512, 16, 32);
test_aligned_offset_realloc(256, 128, 16, 32);
test_aligned_offset_realloc(256, 512, 32, 32);
test_aligned_offset_realloc(256, 128, 32, 32);
test_aligned_offset_realloc(256, 512, 64, 32);
test_aligned_offset_realloc(256, 128, 64, 32);
test_aligned_offset_realloc(256, 512, 0, 64);
test_aligned_offset_realloc(256, 128, 0, 64);
test_aligned_offset_realloc(256, 512, 4, 64);
test_aligned_offset_realloc(256, 128, 4, 64);
test_aligned_offset_realloc(256, 512, 8, 64);
test_aligned_offset_realloc(256, 128, 8, 64);
test_aligned_offset_realloc(256, 512, 16, 64);
test_aligned_offset_realloc(256, 128, 16, 64);
test_aligned_offset_realloc(256, 512, 32, 64);
test_aligned_offset_realloc(256, 128, 32, 64);
test_aligned_offset_realloc(256, 512, 64, 64);
test_aligned_offset_realloc(256, 128, 64, 64);
test_aligned_offset_realloc(256, 512, 0, 96);
test_aligned_offset_realloc(256, 128, 0, 96);
test_aligned_offset_realloc(256, 512, 4, 96);
test_aligned_offset_realloc(256, 128, 4, 96);
test_aligned_offset_realloc(256, 512, 8, 96);
test_aligned_offset_realloc(256, 128, 8, 96);
test_aligned_offset_realloc(256, 512, 16, 96);
test_aligned_offset_realloc(256, 128, 16, 96);
test_aligned_offset_realloc(256, 512, 32, 96);
test_aligned_offset_realloc(256, 128, 32, 96);
test_aligned_offset_realloc(256, 512, 64, 96);
test_aligned_offset_realloc(256, 128, 64, 96);
test_aligned_offset_realloc(256, 512, 0, 112);
test_aligned_offset_realloc(256, 128, 0, 112);
test_aligned_offset_realloc(256, 512, 4, 112);
test_aligned_offset_realloc(256, 128, 4, 112);
test_aligned_offset_realloc(256, 512, 8, 112);
test_aligned_offset_realloc(256, 128, 8, 112);
test_aligned_offset_realloc(256, 512, 16, 112);
test_aligned_offset_realloc(256, 128, 16, 112);
test_aligned_offset_realloc(256, 512, 32, 112);
test_aligned_offset_realloc(256, 128, 32, 112);
test_aligned_offset_realloc(256, 512, 64, 112);
test_aligned_offset_realloc(256, 128, 64, 112);
}
static void test_sbheap(void)
{
void *mem;
int threshold;
if(sizeof(void*) == 8) {
ok(!_set_sbh_threshold(0), "_set_sbh_threshold succeeded\n");
ok(!_set_sbh_threshold(1000), "_set_sbh_threshold succeeded\n");
return;
}
mem = malloc(1);
ok(mem != NULL, "malloc failed\n");
ok(_set_sbh_threshold(1), "_set_sbh_threshold failed\n");
threshold = _get_sbh_threshold();
ok(threshold == 16, "threshold = %d\n", threshold);
ok(_set_sbh_threshold(8), "_set_sbh_threshold failed\n");
threshold = _get_sbh_threshold();
ok(threshold == 16, "threshold = %d\n", threshold);
ok(_set_sbh_threshold(1000), "_set_sbh_threshold failed\n");
threshold = _get_sbh_threshold();
ok(threshold == 1008, "threshold = %d\n", threshold);
free(mem);
mem = malloc(1);
ok(mem != NULL, "malloc failed\n");
ok(!((UINT_PTR)mem & 0xf), "incorrect alignment (%p)\n", mem);
mem = realloc(mem, 10);
ok(mem != NULL, "realloc failed\n");
ok(!((UINT_PTR)mem & 0xf), "incorrect alignment (%p)\n", mem);
ok(_set_sbh_threshold(0), "_set_sbh_threshold failed\n");
threshold = _get_sbh_threshold();
ok(threshold == 0, "threshold = %d\n", threshold);
free(mem);
}
static void test_calloc(void)
{
/* use function pointer to bypass gcc builtin */
void *(__cdecl *p_calloc)(size_t, size_t);
void *ptr;
p_calloc = (void *)GetProcAddress( GetModuleHandleA("msvcrt.dll"), "calloc");
ptr = p_calloc(1, 0);
ok(ptr != NULL, "got %p\n", ptr);
free(ptr);
ptr = p_calloc(0, 0);
ok(ptr != NULL, "got %p\n", ptr);
free(ptr);
ptr = p_calloc(0, 1);
ok(ptr != NULL, "got %p\n", ptr);
free(ptr);
errno = 0;
ptr = p_calloc(~(size_t)0 / 2, ~(size_t)0 / 2);
ok(ptr == NULL || broken(ptr != NULL) /* winxp sp0 */, "got %p\n", ptr);
ok(errno == ENOMEM || broken(errno == 0) /* winxp, win2k3 */, "got errno %d\n", errno);
free(ptr);
}
START_TEST(heap)
{
void *mem;
mem = malloc(0);
ok(mem != NULL, "memory not allocated for size 0\n");
free(mem);
mem = realloc(NULL, 10);
ok(mem != NULL, "memory not allocated\n");
mem = realloc(mem, 20);
ok(mem != NULL, "memory not reallocated\n");
mem = realloc(mem, 0);
ok(mem == NULL, "memory not freed\n");
mem = realloc(NULL, 0);
ok(mem != NULL, "memory not (re)allocated for size 0\n");
free(mem);
test_aligned();
test_sbheap();
test_calloc();
}
Reference in a new issue View git blame Copy permalink