mirror of
https://github.com/fluencelabs/redis
synced 2025-06-30 01:11:33 +00:00
Jemalloc upgraded to version 5.0.1.
This commit is contained in:
antirez
311
deps/jemalloc/test/integration/xallocx.c
vendored
311
deps/jemalloc/test/integration/xallocx.c
vendored
@ -1,7 +1,24 @@
|
||||
#include "test/jemalloc_test.h"
|
||||
|
||||
TEST_BEGIN(test_same_size)
|
||||
{
|
||||
/*
|
||||
* Use a separate arena for xallocx() extension/contraction tests so that
|
||||
* internal allocation e.g. by heap profiling can't interpose allocations where
|
||||
* xallocx() would ordinarily be able to extend.
|
||||
*/
|
||||
static unsigned
|
||||
arena_ind(void) {
|
||||
static unsigned ind = 0;
|
||||
|
||||
if (ind == 0) {
|
||||
size_t sz = sizeof(ind);
|
||||
assert_d_eq(mallctl("arenas.create", (void *)&ind, &sz, NULL,
|
||||
0), 0, "Unexpected mallctl failure creating arena");
|
||||
}
|
||||
|
||||
return ind;
|
||||
}
|
||||
|
||||
TEST_BEGIN(test_same_size) {
|
||||
void *p;
|
||||
size_t sz, tsz;
|
||||
|
||||
@ -16,8 +33,7 @@ TEST_BEGIN(test_same_size)
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_extra_no_move)
|
||||
{
|
||||
TEST_BEGIN(test_extra_no_move) {
|
||||
void *p;
|
||||
size_t sz, tsz;
|
||||
|
||||
@ -32,8 +48,7 @@ TEST_BEGIN(test_extra_no_move)
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_no_move_fail)
|
||||
{
|
||||
TEST_BEGIN(test_no_move_fail) {
|
||||
void *p;
|
||||
size_t sz, tsz;
|
||||
|
||||
@ -49,42 +64,29 @@ TEST_BEGIN(test_no_move_fail)
|
||||
TEST_END
|
||||
|
||||
static unsigned
|
||||
get_nsizes_impl(const char *cmd)
|
||||
{
|
||||
get_nsizes_impl(const char *cmd) {
|
||||
unsigned ret;
|
||||
size_t z;
|
||||
|
||||
z = sizeof(unsigned);
|
||||
assert_d_eq(mallctl(cmd, &ret, &z, NULL, 0), 0,
|
||||
assert_d_eq(mallctl(cmd, (void *)&ret, &z, NULL, 0), 0,
|
||||
"Unexpected mallctl(\"%s\", ...) failure", cmd);
|
||||
|
||||
return (ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static unsigned
|
||||
get_nsmall(void)
|
||||
{
|
||||
|
||||
return (get_nsizes_impl("arenas.nbins"));
|
||||
get_nsmall(void) {
|
||||
return get_nsizes_impl("arenas.nbins");
|
||||
}
|
||||
|
||||
static unsigned
|
||||
get_nlarge(void)
|
||||
{
|
||||
|
||||
return (get_nsizes_impl("arenas.nlruns"));
|
||||
}
|
||||
|
||||
static unsigned
|
||||
get_nhuge(void)
|
||||
{
|
||||
|
||||
return (get_nsizes_impl("arenas.nhchunks"));
|
||||
get_nlarge(void) {
|
||||
return get_nsizes_impl("arenas.nlextents");
|
||||
}
|
||||
|
||||
static size_t
|
||||
get_size_impl(const char *cmd, size_t ind)
|
||||
{
|
||||
get_size_impl(const char *cmd, size_t ind) {
|
||||
size_t ret;
|
||||
size_t z;
|
||||
size_t mib[4];
|
||||
@ -95,41 +97,29 @@ get_size_impl(const char *cmd, size_t ind)
|
||||
0, "Unexpected mallctlnametomib(\"%s\", ...) failure", cmd);
|
||||
mib[2] = ind;
|
||||
z = sizeof(size_t);
|
||||
assert_d_eq(mallctlbymib(mib, miblen, &ret, &z, NULL, 0),
|
||||
assert_d_eq(mallctlbymib(mib, miblen, (void *)&ret, &z, NULL, 0),
|
||||
0, "Unexpected mallctlbymib([\"%s\", %zu], ...) failure", cmd, ind);
|
||||
|
||||
return (ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static size_t
|
||||
get_small_size(size_t ind)
|
||||
{
|
||||
|
||||
return (get_size_impl("arenas.bin.0.size", ind));
|
||||
get_small_size(size_t ind) {
|
||||
return get_size_impl("arenas.bin.0.size", ind);
|
||||
}
|
||||
|
||||
static size_t
|
||||
get_large_size(size_t ind)
|
||||
{
|
||||
|
||||
return (get_size_impl("arenas.lrun.0.size", ind));
|
||||
get_large_size(size_t ind) {
|
||||
return get_size_impl("arenas.lextent.0.size", ind);
|
||||
}
|
||||
|
||||
static size_t
|
||||
get_huge_size(size_t ind)
|
||||
{
|
||||
|
||||
return (get_size_impl("arenas.hchunk.0.size", ind));
|
||||
}
|
||||
|
||||
TEST_BEGIN(test_size)
|
||||
{
|
||||
size_t small0, hugemax;
|
||||
TEST_BEGIN(test_size) {
|
||||
size_t small0, largemax;
|
||||
void *p;
|
||||
|
||||
/* Get size classes. */
|
||||
small0 = get_small_size(0);
|
||||
hugemax = get_huge_size(get_nhuge()-1);
|
||||
largemax = get_large_size(get_nlarge()-1);
|
||||
|
||||
p = mallocx(small0, 0);
|
||||
assert_ptr_not_null(p, "Unexpected mallocx() error");
|
||||
@ -139,60 +129,58 @@ TEST_BEGIN(test_size)
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
/* Test largest supported size. */
|
||||
assert_zu_le(xallocx(p, hugemax, 0, 0), hugemax,
|
||||
assert_zu_le(xallocx(p, largemax, 0, 0), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
/* Test size overflow. */
|
||||
assert_zu_le(xallocx(p, hugemax+1, 0, 0), hugemax,
|
||||
assert_zu_le(xallocx(p, largemax+1, 0, 0), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_le(xallocx(p, SIZE_T_MAX, 0, 0), hugemax,
|
||||
assert_zu_le(xallocx(p, SIZE_T_MAX, 0, 0), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
dallocx(p, 0);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_size_extra_overflow)
|
||||
{
|
||||
size_t small0, hugemax;
|
||||
TEST_BEGIN(test_size_extra_overflow) {
|
||||
size_t small0, largemax;
|
||||
void *p;
|
||||
|
||||
/* Get size classes. */
|
||||
small0 = get_small_size(0);
|
||||
hugemax = get_huge_size(get_nhuge()-1);
|
||||
largemax = get_large_size(get_nlarge()-1);
|
||||
|
||||
p = mallocx(small0, 0);
|
||||
assert_ptr_not_null(p, "Unexpected mallocx() error");
|
||||
|
||||
/* Test overflows that can be resolved by clamping extra. */
|
||||
assert_zu_le(xallocx(p, hugemax-1, 2, 0), hugemax,
|
||||
assert_zu_le(xallocx(p, largemax-1, 2, 0), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_le(xallocx(p, hugemax, 1, 0), hugemax,
|
||||
assert_zu_le(xallocx(p, largemax, 1, 0), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
/* Test overflow such that hugemax-size underflows. */
|
||||
assert_zu_le(xallocx(p, hugemax+1, 2, 0), hugemax,
|
||||
/* Test overflow such that largemax-size underflows. */
|
||||
assert_zu_le(xallocx(p, largemax+1, 2, 0), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_le(xallocx(p, hugemax+2, 3, 0), hugemax,
|
||||
assert_zu_le(xallocx(p, largemax+2, 3, 0), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_le(xallocx(p, SIZE_T_MAX-2, 2, 0), hugemax,
|
||||
assert_zu_le(xallocx(p, SIZE_T_MAX-2, 2, 0), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_le(xallocx(p, SIZE_T_MAX-1, 1, 0), hugemax,
|
||||
assert_zu_le(xallocx(p, SIZE_T_MAX-1, 1, 0), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
dallocx(p, 0);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_extra_small)
|
||||
{
|
||||
size_t small0, small1, hugemax;
|
||||
TEST_BEGIN(test_extra_small) {
|
||||
size_t small0, small1, largemax;
|
||||
void *p;
|
||||
|
||||
/* Get size classes. */
|
||||
small0 = get_small_size(0);
|
||||
small1 = get_small_size(1);
|
||||
hugemax = get_huge_size(get_nhuge()-1);
|
||||
largemax = get_large_size(get_nlarge()-1);
|
||||
|
||||
p = mallocx(small0, 0);
|
||||
assert_ptr_not_null(p, "Unexpected mallocx() error");
|
||||
@ -207,7 +195,7 @@ TEST_BEGIN(test_extra_small)
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
/* Test size+extra overflow. */
|
||||
assert_zu_eq(xallocx(p, small0, hugemax - small0 + 1, 0), small0,
|
||||
assert_zu_eq(xallocx(p, small0, largemax - small0 + 1, 0), small0,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_eq(xallocx(p, small0, SIZE_T_MAX - small0, 0), small0,
|
||||
"Unexpected xallocx() behavior");
|
||||
@ -216,140 +204,77 @@ TEST_BEGIN(test_extra_small)
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_extra_large)
|
||||
{
|
||||
size_t smallmax, large0, large1, large2, huge0, hugemax;
|
||||
TEST_BEGIN(test_extra_large) {
|
||||
int flags = MALLOCX_ARENA(arena_ind());
|
||||
size_t smallmax, large1, large2, large3, largemax;
|
||||
void *p;
|
||||
|
||||
/* Get size classes. */
|
||||
smallmax = get_small_size(get_nsmall()-1);
|
||||
large0 = get_large_size(0);
|
||||
large1 = get_large_size(1);
|
||||
large2 = get_large_size(2);
|
||||
huge0 = get_huge_size(0);
|
||||
hugemax = get_huge_size(get_nhuge()-1);
|
||||
|
||||
p = mallocx(large2, 0);
|
||||
assert_ptr_not_null(p, "Unexpected mallocx() error");
|
||||
|
||||
assert_zu_eq(xallocx(p, large2, 0, 0), large2,
|
||||
"Unexpected xallocx() behavior");
|
||||
/* Test size decrease with zero extra. */
|
||||
assert_zu_eq(xallocx(p, large0, 0, 0), large0,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_eq(xallocx(p, smallmax, 0, 0), large0,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
assert_zu_eq(xallocx(p, large2, 0, 0), large2,
|
||||
"Unexpected xallocx() behavior");
|
||||
/* Test size decrease with non-zero extra. */
|
||||
assert_zu_eq(xallocx(p, large0, large2 - large0, 0), large2,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_eq(xallocx(p, large1, large2 - large1, 0), large2,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_eq(xallocx(p, large0, large1 - large0, 0), large1,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_eq(xallocx(p, smallmax, large0 - smallmax, 0), large0,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
assert_zu_eq(xallocx(p, large0, 0, 0), large0,
|
||||
"Unexpected xallocx() behavior");
|
||||
/* Test size increase with zero extra. */
|
||||
assert_zu_eq(xallocx(p, large2, 0, 0), large2,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_eq(xallocx(p, huge0, 0, 0), large2,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
assert_zu_eq(xallocx(p, large0, 0, 0), large0,
|
||||
"Unexpected xallocx() behavior");
|
||||
/* Test size increase with non-zero extra. */
|
||||
assert_zu_lt(xallocx(p, large0, huge0 - large0, 0), huge0,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
assert_zu_eq(xallocx(p, large0, 0, 0), large0,
|
||||
"Unexpected xallocx() behavior");
|
||||
/* Test size increase with non-zero extra. */
|
||||
assert_zu_eq(xallocx(p, large0, large2 - large0, 0), large2,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
assert_zu_eq(xallocx(p, large2, 0, 0), large2,
|
||||
"Unexpected xallocx() behavior");
|
||||
/* Test size+extra overflow. */
|
||||
assert_zu_lt(xallocx(p, large2, hugemax - large2 + 1, 0), huge0,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
dallocx(p, 0);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_extra_huge)
|
||||
{
|
||||
size_t largemax, huge0, huge1, huge2, hugemax;
|
||||
void *p;
|
||||
|
||||
/* Get size classes. */
|
||||
large3 = get_large_size(3);
|
||||
largemax = get_large_size(get_nlarge()-1);
|
||||
huge0 = get_huge_size(0);
|
||||
huge1 = get_huge_size(1);
|
||||
huge2 = get_huge_size(2);
|
||||
hugemax = get_huge_size(get_nhuge()-1);
|
||||
|
||||
p = mallocx(huge2, 0);
|
||||
p = mallocx(large3, flags);
|
||||
assert_ptr_not_null(p, "Unexpected mallocx() error");
|
||||
|
||||
assert_zu_eq(xallocx(p, huge2, 0, 0), huge2,
|
||||
assert_zu_eq(xallocx(p, large3, 0, flags), large3,
|
||||
"Unexpected xallocx() behavior");
|
||||
/* Test size decrease with zero extra. */
|
||||
assert_zu_ge(xallocx(p, huge0, 0, 0), huge0,
|
||||
assert_zu_ge(xallocx(p, large1, 0, flags), large1,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_ge(xallocx(p, largemax, 0, 0), huge0,
|
||||
assert_zu_ge(xallocx(p, smallmax, 0, flags), large1,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
assert_zu_eq(xallocx(p, huge2, 0, 0), huge2,
|
||||
"Unexpected xallocx() behavior");
|
||||
if (xallocx(p, large3, 0, flags) != large3) {
|
||||
p = rallocx(p, large3, flags);
|
||||
assert_ptr_not_null(p, "Unexpected rallocx() failure");
|
||||
}
|
||||
/* Test size decrease with non-zero extra. */
|
||||
assert_zu_eq(xallocx(p, huge0, huge2 - huge0, 0), huge2,
|
||||
assert_zu_eq(xallocx(p, large1, large3 - large1, flags), large3,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_eq(xallocx(p, huge1, huge2 - huge1, 0), huge2,
|
||||
assert_zu_eq(xallocx(p, large2, large3 - large2, flags), large3,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_eq(xallocx(p, huge0, huge1 - huge0, 0), huge1,
|
||||
assert_zu_ge(xallocx(p, large1, large2 - large1, flags), large2,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_ge(xallocx(p, largemax, huge0 - largemax, 0), huge0,
|
||||
assert_zu_ge(xallocx(p, smallmax, large1 - smallmax, flags), large1,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
assert_zu_ge(xallocx(p, huge0, 0, 0), huge0,
|
||||
assert_zu_ge(xallocx(p, large1, 0, flags), large1,
|
||||
"Unexpected xallocx() behavior");
|
||||
/* Test size increase with zero extra. */
|
||||
assert_zu_le(xallocx(p, huge2, 0, 0), huge2,
|
||||
assert_zu_le(xallocx(p, large3, 0, flags), large3,
|
||||
"Unexpected xallocx() behavior");
|
||||
assert_zu_le(xallocx(p, hugemax+1, 0, 0), huge2,
|
||||
assert_zu_le(xallocx(p, largemax+1, 0, flags), large3,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
assert_zu_ge(xallocx(p, huge0, 0, 0), huge0,
|
||||
assert_zu_ge(xallocx(p, large1, 0, flags), large1,
|
||||
"Unexpected xallocx() behavior");
|
||||
/* Test size increase with non-zero extra. */
|
||||
assert_zu_le(xallocx(p, huge0, SIZE_T_MAX - huge0, 0), hugemax,
|
||||
assert_zu_le(xallocx(p, large1, SIZE_T_MAX - large1, flags), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
assert_zu_ge(xallocx(p, huge0, 0, 0), huge0,
|
||||
assert_zu_ge(xallocx(p, large1, 0, flags), large1,
|
||||
"Unexpected xallocx() behavior");
|
||||
/* Test size increase with non-zero extra. */
|
||||
assert_zu_le(xallocx(p, huge0, huge2 - huge0, 0), huge2,
|
||||
assert_zu_le(xallocx(p, large1, large3 - large1, flags), large3,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
assert_zu_eq(xallocx(p, huge2, 0, 0), huge2,
|
||||
"Unexpected xallocx() behavior");
|
||||
if (xallocx(p, large3, 0, flags) != large3) {
|
||||
p = rallocx(p, large3, flags);
|
||||
assert_ptr_not_null(p, "Unexpected rallocx() failure");
|
||||
}
|
||||
/* Test size+extra overflow. */
|
||||
assert_zu_le(xallocx(p, huge2, hugemax - huge2 + 1, 0), hugemax,
|
||||
assert_zu_le(xallocx(p, large3, largemax - large3 + 1, flags), largemax,
|
||||
"Unexpected xallocx() behavior");
|
||||
|
||||
dallocx(p, 0);
|
||||
dallocx(p, flags);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
static void
|
||||
print_filled_extents(const void *p, uint8_t c, size_t len)
|
||||
{
|
||||
print_filled_extents(const void *p, uint8_t c, size_t len) {
|
||||
const uint8_t *pc = (const uint8_t *)p;
|
||||
size_t i, range0;
|
||||
uint8_t c0;
|
||||
@ -368,32 +293,33 @@ print_filled_extents(const void *p, uint8_t c, size_t len)
|
||||
}
|
||||
|
||||
static bool
|
||||
validate_fill(const void *p, uint8_t c, size_t offset, size_t len)
|
||||
{
|
||||
validate_fill(const void *p, uint8_t c, size_t offset, size_t len) {
|
||||
const uint8_t *pc = (const uint8_t *)p;
|
||||
bool err;
|
||||
size_t i;
|
||||
|
||||
for (i = offset, err = false; i < offset+len; i++) {
|
||||
if (pc[i] != c)
|
||||
if (pc[i] != c) {
|
||||
err = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (err)
|
||||
if (err) {
|
||||
print_filled_extents(p, c, offset + len);
|
||||
}
|
||||
|
||||
return (err);
|
||||
return err;
|
||||
}
|
||||
|
||||
static void
|
||||
test_zero(size_t szmin, size_t szmax)
|
||||
{
|
||||
test_zero(size_t szmin, size_t szmax) {
|
||||
int flags = MALLOCX_ARENA(arena_ind()) | MALLOCX_ZERO;
|
||||
size_t sz, nsz;
|
||||
void *p;
|
||||
#define FILL_BYTE 0x7aU
|
||||
#define FILL_BYTE 0x7aU
|
||||
|
||||
sz = szmax;
|
||||
p = mallocx(sz, MALLOCX_ZERO);
|
||||
p = mallocx(sz, flags);
|
||||
assert_ptr_not_null(p, "Unexpected mallocx() error");
|
||||
assert_false(validate_fill(p, 0x00, 0, sz), "Memory not filled: sz=%zu",
|
||||
sz);
|
||||
@ -408,15 +334,19 @@ test_zero(size_t szmin, size_t szmax)
|
||||
|
||||
/* Shrink in place so that we can expect growing in place to succeed. */
|
||||
sz = szmin;
|
||||
assert_zu_eq(xallocx(p, sz, 0, MALLOCX_ZERO), sz,
|
||||
"Unexpected xallocx() error");
|
||||
if (xallocx(p, sz, 0, flags) != sz) {
|
||||
p = rallocx(p, sz, flags);
|
||||
assert_ptr_not_null(p, "Unexpected rallocx() failure");
|
||||
}
|
||||
assert_false(validate_fill(p, FILL_BYTE, 0, sz),
|
||||
"Memory not filled: sz=%zu", sz);
|
||||
|
||||
for (sz = szmin; sz < szmax; sz = nsz) {
|
||||
nsz = nallocx(sz+1, MALLOCX_ZERO);
|
||||
assert_zu_eq(xallocx(p, sz+1, 0, MALLOCX_ZERO), nsz,
|
||||
"Unexpected xallocx() failure");
|
||||
nsz = nallocx(sz+1, flags);
|
||||
if (xallocx(p, sz+1, 0, flags) != nsz) {
|
||||
p = rallocx(p, sz+1, flags);
|
||||
assert_ptr_not_null(p, "Unexpected rallocx() failure");
|
||||
}
|
||||
assert_false(validate_fill(p, FILL_BYTE, 0, sz),
|
||||
"Memory not filled: sz=%zu", sz);
|
||||
assert_false(validate_fill(p, 0x00, sz, nsz-sz),
|
||||
@ -426,38 +356,23 @@ test_zero(size_t szmin, size_t szmax)
|
||||
"Memory not filled: nsz=%zu", nsz);
|
||||
}
|
||||
|
||||
dallocx(p, 0);
|
||||
dallocx(p, flags);
|
||||
}
|
||||
|
||||
TEST_BEGIN(test_zero_large)
|
||||
{
|
||||
size_t large0, largemax;
|
||||
TEST_BEGIN(test_zero_large) {
|
||||
size_t large0, large1;
|
||||
|
||||
/* Get size classes. */
|
||||
large0 = get_large_size(0);
|
||||
largemax = get_large_size(get_nlarge()-1);
|
||||
large1 = get_large_size(1);
|
||||
|
||||
test_zero(large0, largemax);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
TEST_BEGIN(test_zero_huge)
|
||||
{
|
||||
size_t huge0, huge1;
|
||||
|
||||
/* Get size classes. */
|
||||
huge0 = get_huge_size(0);
|
||||
huge1 = get_huge_size(1);
|
||||
|
||||
test_zero(huge1, huge0 * 2);
|
||||
test_zero(large1, large0 * 2);
|
||||
}
|
||||
TEST_END
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
|
||||
return (test(
|
||||
main(void) {
|
||||
return test(
|
||||
test_same_size,
|
||||
test_extra_no_move,
|
||||
test_no_move_fail,
|
||||
@ -465,7 +380,5 @@ main(void)
|
||||
test_size_extra_overflow,
|
||||
test_extra_small,
|
||||
test_extra_large,
|
||||
test_extra_huge,
|
||||
test_zero_large,
|
||||
test_zero_huge));
|
||||
test_zero_large);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user