Context Navigation

source: tests/alloc2.cfa @ 5b7a3662

ADTast-experimentalenumforall-pointer-decaypthread-emulationqualifiedEnum

Last change on this file since 5b7a3662 was ea561c9, checked in by Peter A. Buhr <pabuhr@…>, 4 years ago
change printf format for size_t to %zu
Property mode set to `100644`
File size: 23.2 KB

Rev	Line
[191a190]	1	#include <malloc.h> // malloc_usable_size
	2	#include <stdint.h> // uintptr_t
	3	#include <stdlib.hfa> // access C malloc, realloc
	4	#include <string.h> // memcmp
	5
	6	int last_failed;
	7	int tests_total;
	8	int tests_failed;
	9	size_t tAlign = 32;
	10	struct S1 { int data; } __attribute__((aligned(32)));
	11	typedef struct S1 T1;
	12
	13	void test_base( void * ip, size_t size, size_t align) {
	14	tests_total += 1;
[1b55756]	15	// printf("DEBUG: starting test %d\n", tests_total);
[191a190]	16	bool passed = (malloc_size(ip) == size) && (malloc_usable_size(ip) >= size) && (malloc_alignment(ip) == align) && ((uintptr_t)ip % align == 0);
	17	if (!passed) {
[ea561c9]	18	printf("failed test %3d: %4zu %4zu but got %4zu ( %3zu ) %4zu\n", tests_total, size, align, malloc_size(ip), malloc_usable_size(ip), malloc_alignment(ip));
[f76ff0b]	19	tests_failed += 1;
[191a190]	20	}
[1b55756]	21	// printf("DEBUG: done test %d\n", tests_total);
[191a190]	22	}
	23
	24	void test_fill( void * ip_, size_t start, size_t end, char fill) {
	25	tests_total += 1;
[1b55756]	26	// printf("DEBUG: starting test %d\n", tests_total);
[191a190]	27	bool passed = true;
	28	char * ip = (char *) ip_;
	29	for (i; start ~ end) passed = passed && (ip[i] == fill);
	30	if (!passed) {
	31	printf("failed test %3d: fill C\n", tests_total);
[f76ff0b]	32	tests_failed += 1;
[191a190]	33	}
[1b55756]	34	// printf("DEBUG: done test %d\n", tests_total);
[191a190]	35	}
	36
	37	void test_fill( void * ip_, size_t start, size_t end, int fill) {
	38	tests_total += 1;
[1b55756]	39	// printf("DEBUG: starting test %d\n", tests_total);
[191a190]	40	bool passed = true;
	41	int * ip = (int *) ip_;
	42	for (i; start ~ end) passed = passed && (ip[i] == fill);
	43	if (!passed) {
	44	printf("failed test %3d: fill int\n", tests_total);
[f76ff0b]	45	tests_failed += 1;
[191a190]	46	}
[1b55756]	47	// printf("DEBUG: done test %d\n", tests_total);
[191a190]	48	}
	49
	50	void test_fill( void * ip_, size_t start, size_t end, int * fill) {
	51	tests_total += 1;
[1b55756]	52	// printf("DEBUG: starting test %d\n", tests_total);
[191a190]	53	bool passed = (memcmp((void)((uintptr_t)ip_ + start), (void)fill, end) == 0);
	54	if (!passed) {
	55	printf("failed test %3d: fill int A\n", tests_total);
[f76ff0b]	56	tests_failed += 1;
[191a190]	57	}
[1b55756]	58	// printf("DEBUG: done test %d\n", tests_total);
[191a190]	59	}
	60
	61	void test_fill( void * ip_, size_t start, size_t end, T1 fill) {
	62	tests_total += 1;
[1b55756]	63	// printf("DEBUG: starting test %d\n", tests_total);
[191a190]	64	bool passed = true;
	65	T1 * ip = (T1 *) ip_;
	66	for (i; start ~ end) passed = passed && (ip[i].data == fill.data);
	67	if (!passed) {
	68	printf("failed test %3d: fill T1\n", tests_total);
[f76ff0b]	69	tests_failed += 1;
[191a190]	70	}
[1b55756]	71	// printf("DEBUG: done test %d\n", tests_total);
[191a190]	72	}
	73
	74	void test_fill( void * ip_, size_t start, size_t end, T1 * fill) {
	75	tests_total += 1;
[1b55756]	76	// printf("DEBUG: starting test %d\n", tests_total);
[191a190]	77	bool passed = (memcmp((void)((uintptr_t)ip_ + start), (void)fill, end) == 0);
	78	if (!passed) {
	79	printf("failed test %3d: fill T1 A\n", tests_total);
[f76ff0b]	80	tests_failed += 1;
[191a190]	81	}
[1b55756]	82	// printf("DEBUG: done test %d\n", tests_total);
[191a190]	83	}
	84
	85	void test_use( int * ip, size_t dim) {
	86	tests_total += 1;
[1b55756]	87	// printf("DEBUG: starting test %d\n", tests_total);
[191a190]	88	bool passed = true;
	89	for (i; 0 ~ dim) ip[i] = 0xdeadbeef;
	90	for (i; 0 ~ dim) passed = passed && (ip[i] == 0xdeadbeef);
	91	if (!passed) {
	92	printf("failed test %3d: use int\n", tests_total);
[f76ff0b]	93	tests_failed += 1;
[191a190]	94	}
[1b55756]	95	// printf("DEBUG: done test %d\n", tests_total);
[191a190]	96	}
	97
	98	void test_use( T1 * ip, size_t dim) {
	99	tests_total += 1;
[1b55756]	100	// printf("DEBUG: starting test %d\n", tests_total);
[191a190]	101	bool passed = true;
	102	for (i; 0 ~ dim) ip[i].data = 0xdeadbeef;
	103	for (i; 0 ~ dim) passed = passed && (ip[i].data == 0xdeadbeef);
	104	if (!passed) {
	105	printf("failed test %3d: use T1\n", tests_total);
[f76ff0b]	106	tests_failed += 1;
[191a190]	107	}
[1b55756]	108	// printf("DEBUG: done test %d\n", tests_total);
[191a190]	109	}
	110
	111	int main( void ) {
	112	size_t elemSize = sizeof(int);
	113	size_t dim = 8;
	114	size_t size = dim * elemSize;
	115	size_t align = 64;
	116	const size_t libAlign = libAlign();
	117
	118	int FillT = 9;
	119	char FillC = 'a';
	120	int * FillA = calloc(dim / 4);
	121	T1 FillT1 = { FillT };
	122	T1 * FillT1A = (T1 )(void ) malloc( (dim / 4) * sizeof(T1) );
	123	for (i; 0 ~ (dim / 4) ) FillT1A[i] = FillT1;
	124
	125	int * ip;
	126	int * op;
	127	double * dp;
	128	T1 * t1p;
	129	T1 * t1op;
	130
	131	// testing alloc
	132
	133	last_failed = -1;
	134	tests_total = 0;
	135	tests_failed = 0;
	136
	137	ip = alloc();
	138	test_base(ip, elemSize, libAlign);
	139	test_use(ip, elemSize / elemSize);
	140	free(ip);
	141
	142	ip = alloc( dim );
	143	test_base(ip, size, libAlign);
	144	test_use(ip, size / elemSize);
	145	free(ip);
	146
	147	ip = alloc( 0 );
	148	test_base(ip, 0, libAlign);
	149	free(ip);
	150
	151	dp = alloc( dim );
	152	ip = alloc( dp`resize );
	153	test_base(ip, elemSize, libAlign);
	154	test_use(ip, elemSize / elemSize);
	155	free(ip);
	156
	157	ip = alloc( ((double*)0p)`resize );
	158	test_base(ip, elemSize, libAlign);
	159	test_use(ip, elemSize / elemSize);
	160	free(ip);
	161
	162	dp = alloc( dim );
	163	ip = alloc( dim, dp`resize );
	164	test_base(ip, size, libAlign);
	165	test_use(ip, size / elemSize);
	166	free(ip);
	167
	168	dp = alloc( dim );
	169	ip = alloc( 0, dp`resize );
	170	test_base(ip, 0, libAlign);
	171	free(ip);
	172
	173	ip = alloc( dim, ((double*)0p)`resize );
	174	test_base(ip, size, libAlign);
	175	test_use(ip, size / elemSize);
	176	free(ip);
	177
	178	ip = alloc( 0, ((double*)0p)`resize );
	179	test_base(ip, 0, libAlign);
	180	free(ip);
	181
	182	op = alloc( dim, ((int)0xdeadbeef)`fill );
	183	ip = alloc( dim, op`realloc );
	184	test_base(ip, size, libAlign);
	185	test_fill(ip, 0, dim, (int)0xdeadbeef);
	186	test_use(ip, size / elemSize);
	187	free(ip);
	188
	189	op = alloc( dim, ((int)0xdeadbeef)`fill );
	190	ip = alloc( 0, op`realloc );
	191	test_base(ip, 0, libAlign);
	192	free(ip);
	193
	194	ip = alloc( dim, ((int*)0p)`realloc );
	195	test_base(ip, size, libAlign);
	196	test_use(ip, size / elemSize);
	197	free(ip);
	198
	199	ip = alloc( 0, ((int*)0p)`realloc );
	200	test_base(ip, 0, libAlign);
	201	free(ip);
	202
	203	op = alloc( dim, ((int)0xdeadbeef)`fill );
	204	ip = alloc( dim, op`resize );
	205	test_base(ip, size, libAlign);
	206	test_use(ip, size / elemSize);
	207	free(ip);
	208
	209	ip = alloc( FillC`fill );
	210	test_base(ip, elemSize, libAlign);
	211	test_fill(ip, 0, elemSize, FillC);
	212	test_use(ip, elemSize / elemSize);
	213	free(ip);
	214
	215	ip = alloc( FillT`fill );
	216	test_base(ip, elemSize, libAlign);
	217	test_fill(ip, 0, 1, FillT);
	218	test_use(ip, elemSize / elemSize);
	219	free(ip);
	220
	221	ip = alloc( dim, FillC`fill );
	222	test_base(ip, size, libAlign);
	223	test_fill(ip, 0, size, FillC);
	224	test_use(ip, size / elemSize);
	225	free(ip);
	226
	227	ip = alloc( 0, FillC`fill );
	228	test_base(ip, 0, libAlign);
	229	free(ip);
	230
	231	ip = alloc( dim, FillT`fill );
	232	test_base(ip, size, libAlign);
	233	test_fill(ip, 0, dim, FillT);
	234	test_use(ip, size / elemSize);
	235	free(ip);
	236
	237	ip = alloc( 0, FillT`fill );
	238	test_base(ip, 0, libAlign);
	239	free(ip);
	240
	241	ip = alloc( dim, [FillA, dim/4]`fill );
	242	test_base(ip, size, libAlign);
	243	test_fill(ip, 0, size/4, FillA);
	244	test_use(ip, size / elemSize);
	245	free(ip);
	246
	247	ip = alloc( 0, [FillA, dim/4]`fill );
	248	test_base(ip, 0, libAlign);
	249	free(ip);
	250
	251	op = alloc( dim, ((int)0xdeadbeef)`fill );
	252	ip = alloc( dim, op`realloc, FillC`fill );
	253	test_base(ip, size, libAlign);
	254	test_fill(ip, 0, dim, (int)0xdeadbeef);
	255	test_use(ip, size / elemSize);
	256	free(ip);
	257
	258	op = alloc( dim, ((int)0xdeadbeef)`fill );
	259	ip = alloc( dim / 4, op`realloc, FillC`fill );
	260	test_base(ip, size / 4, libAlign);
	261	test_fill(ip, 0, dim / 4, (int)0xdeadbeef);
	262	test_use(ip, size / 4 / elemSize);
	263	free(ip);
	264
	265	op = alloc( dim, ((int)0xdeadbeef)`fill );
	266	ip = alloc( dim * 4, op`realloc, FillC`fill );
	267	test_base(ip, size * 4, libAlign);
	268	test_fill(ip, 0, dim, (int)0xdeadbeef);
	269	test_fill(ip, size, size * 4, FillC);
	270	test_use(ip, size * 4 / elemSize);
	271	free(ip);
	272
	273	op = alloc( dim, ((int)0xdeadbeef)`fill );
	274	ip = alloc( 0, op`realloc, FillC`fill );
	275	test_base(ip, 0, libAlign);
	276	free(ip);
	277
	278	ip = alloc( dim, ((int*)0p)`realloc, FillC`fill );
	279	test_base(ip, size, libAlign);
	280	test_fill(ip, 0, size, FillC);
	281	test_use(ip, size / elemSize);
	282	free(ip);
	283
	284	ip = alloc( 0, ((int*)0p)`realloc, FillC`fill );
	285	test_base(ip, 0, libAlign);
	286	free(ip);
	287
	288	op = alloc( dim, ((int)0xdeadbeef)`fill );
	289	ip = alloc( dim, op`realloc, FillT`fill );
	290	test_base(ip, size, libAlign);
	291	test_fill(ip, 0, dim, (int)0xdeadbeef);
	292	test_use(ip, size / elemSize);
	293	free(ip);
	294
	295	op = alloc( dim, ((int)0xdeadbeef)`fill );
	296	ip = alloc( dim / 4, op`realloc, FillT`fill );
	297	test_base(ip, size / 4, libAlign);
	298	test_fill(ip, 0, dim / 4, (int)0xdeadbeef);
	299	test_use(ip, size / 4 / elemSize);
	300	free(ip);
	301
	302	op = alloc( dim, ((int)0xdeadbeef)`fill );
	303	ip = alloc( dim * 4, op`realloc, FillT`fill );
	304	test_base(ip, size * 4, libAlign);
	305	test_fill(ip, 0, dim, (int)0xdeadbeef);
	306	test_fill(ip, dim, dim * 4, FillT);
	307	test_use(ip, size * 4 / elemSize);
	308	free(ip);
	309
	310	op = alloc( dim, ((int)0xdeadbeef)`fill );
	311	ip = alloc( 0, op`realloc, FillT`fill );
	312	test_base(ip, 0, libAlign);
	313	free(ip);
	314
	315	ip = alloc( dim, ((int*)0p)`realloc, FillT`fill );
	316	test_base(ip, size, libAlign);
	317	test_fill(ip, 0, dim, FillT);
	318	test_use(ip, size / elemSize);
	319	free(ip);
	320
[f76ff0b]	321	ip = alloc( 0, ((int*)0p)`realloc, FillT`fill );
	322	test_base(ip, 0, libAlign);
	323	free(ip);
[191a190]	324
	325	ip = alloc( align`align );
	326	test_base(ip, elemSize, align);
	327	test_use(ip, elemSize / elemSize);
	328	free(ip);
	329
	330	ip = alloc( dim, align`align );
	331	test_base(ip, size, align);
	332	test_use(ip, size / elemSize);
	333	free(ip);
	334
	335	ip = alloc( 0, align`align );
	336	test_base(ip, 0, libAlign);
	337	free(ip);
	338
	339	op = alloc( dim, ((int)0xdeadbeef)`fill );
	340	ip = alloc( op`realloc, align`align );
	341	test_base(ip, elemSize, align);
	342	test_fill(ip, 0, 1, (int)0xdeadbeef);
	343	test_use(ip, elemSize / elemSize);
	344	free(ip);
	345
[f76ff0b]	346	ip = alloc( ((int*)0p)`realloc, align`align );
	347	test_base(ip, elemSize, align);
	348	test_use(ip, elemSize / elemSize);
	349	free(ip);
[191a190]	350
	351	dp = alloc( dim );
	352	ip = alloc( dp`resize, align`align );
	353	test_base(ip, elemSize, align);
	354	test_use(ip, elemSize / elemSize);
	355	free(ip);
	356
[f76ff0b]	357	ip = alloc( ((double*)0p)`resize, align`align );
	358	test_base(ip, elemSize, align);
	359	test_use(ip, elemSize / elemSize);
	360	free(ip);
[191a190]	361
	362	op = alloc( dim, ((int)0xdeadbeef)`fill);
	363	ip = alloc( dim, op`realloc, align`align );
	364	test_base(ip, size, align);
	365	test_fill(ip, 0, dim, (int)0xdeadbeef);
	366	test_use(ip, size / elemSize);
	367	free(ip);
	368
	369	op = alloc( dim, ((int)0xdeadbeef)`fill );
	370	ip = alloc( 0, op`realloc, align`align );
	371	test_base(ip, 0, libAlign);
	372	free(ip);
	373
[f76ff0b]	374	ip = alloc( dim, ((int*)0p)`realloc, align`align );
	375	test_base(ip, size, align);
	376	test_use(ip, size / elemSize);
	377	free(ip);
[191a190]	378
[f76ff0b]	379	ip = alloc( 0, ((int*)0p)`realloc, align`align );
	380	test_base(ip, 0, libAlign);
	381	free(ip);
[191a190]	382
	383	ip = alloc( align`align, FillC`fill );
	384	test_base(ip, elemSize, align);
	385	test_fill(ip, 0, elemSize, FillC);
	386	test_use(ip, elemSize / elemSize);
	387	free(ip);
	388
	389	ip = alloc( align`align, FillT`fill );
	390	test_base(ip, elemSize, align);
	391	test_fill(ip, 0, 1, FillT);
	392	test_use(ip, elemSize / elemSize);
	393	free(ip);
	394
	395	ip = alloc( dim, align`align, FillC`fill );
	396	test_base(ip, size, align);
	397	test_fill(ip, 0, size, FillC);
	398	test_use(ip, size / elemSize);
	399	free(ip);
	400
	401	ip = alloc( 0, align`align, FillC`fill );
	402	test_base(ip, 0, libAlign);
	403	free(ip);
	404
	405	ip = alloc( dim, align`align, FillT`fill );
	406	test_base(ip, size, align);
	407	test_fill(ip, 0, dim, FillT);
	408	test_use(ip, size / elemSize);
	409	free(ip);
	410
	411	ip = alloc( 0, align`align, FillT`fill );
	412	test_base(ip, 0, libAlign);
	413	free(ip);
	414
	415	ip = alloc( dim, align`align, [FillA, dim/4]`fill );
	416	test_base(ip, size, align);
	417	test_fill(ip, 0, size/4, FillA);
	418	test_use(ip, size / elemSize);
	419	free(ip);
	420
	421	ip = alloc( 0, align`align, [FillA, dim/4]`fill );
	422	test_base(ip, 0, libAlign);
	423	free(ip);
	424
	425	op = alloc( dim, ((int)0xdeadbeef)`fill );
	426	ip = alloc( dim, op`realloc, align`align, FillC`fill );
	427	test_base(ip, size, align);
	428	test_fill(ip, 0, dim, (int)0xdeadbeef);
	429	test_use(ip, size / elemSize);
	430	free(ip);
	431
	432	op = alloc( dim, ((int)0xdeadbeef)`fill );
	433	ip = alloc( dim / 4, op`realloc, align`align, FillC`fill );
	434	test_base(ip, size / 4, align);
	435	test_fill(ip, 0, dim / 4, (int)0xdeadbeef);
	436	test_use(ip, size / 4 / elemSize);
	437	free(ip);
	438
	439	op = alloc( dim, ((int)0xdeadbeef)`fill );
	440	ip = alloc( dim * 4, op`realloc, align`align, FillC`fill );
	441	test_base(ip, size * 4, align);
	442	test_fill(ip, 0, dim, (int)0xdeadbeef);
	443	test_fill(ip, size, size * 4, FillC);
	444	test_use(ip, size * 4 / elemSize);
	445	free(ip);
	446
	447	op = alloc( dim, ((int)0xdeadbeef)`fill );
	448	ip = alloc( 0, op`realloc, align`align, FillC`fill );
	449	test_base(ip, 0, libAlign);
	450	free(ip);
	451
[f76ff0b]	452	ip = alloc( dim, ((int*)0p)`realloc, align`align, FillC`fill );
	453	test_base(ip, size, align);
	454	test_fill(ip, 0, size, FillC);
	455	test_use(ip, size / elemSize);
	456	free(ip);
[191a190]	457
[f76ff0b]	458	ip = alloc( 0, ((int*)0p)`realloc, align`align, FillC`fill );
	459	test_base(ip, 0, libAlign);
	460	free(ip);
[191a190]	461
	462	op = alloc( dim, ((int)0xdeadbeef)`fill );
	463	ip = alloc( dim, op`realloc, align`align, FillT`fill );
	464	test_base(ip, size, align);
	465	test_fill(ip, 0, dim, (int)0xdeadbeef);
	466	test_use(ip, size / elemSize);
	467	free(ip);
	468
	469	op = alloc( dim, ((int)0xdeadbeef)`fill );
	470	ip = alloc( dim / 4, op`realloc, align`align, FillT`fill );
	471	test_base(ip, size / 4, align);
	472	test_fill(ip, 0, dim / 4, (int)0xdeadbeef);
	473	test_use(ip, size / 4 / elemSize);
	474	free(ip);
	475
	476	op = alloc( dim, ((int)0xdeadbeef)`fill );
	477	ip = alloc( dim * 4, op`realloc, align`align, FillT`fill );
	478	test_base(ip, size * 4, align);
	479	test_fill(ip, 0, dim, (int)0xdeadbeef);
	480	test_fill(ip, dim, dim * 4, FillT);
	481	test_use(ip, size * 4 / elemSize);
	482	free(ip);
	483
	484	op = alloc( dim, ((int)0xdeadbeef)`fill );
	485	ip = alloc( 0, op`realloc, align`align, FillT`fill );
	486	test_base(ip, 0, libAlign);
	487	free(ip);
	488
[f76ff0b]	489	ip = alloc( dim, ((int*)0p)`realloc, align`align, FillT`fill );
	490	test_base(ip, size, align);
	491	test_fill(ip, 0, dim, FillT);
	492	test_use(ip, size / elemSize);
	493	free(ip);
[191a190]	494
[f76ff0b]	495	ip = alloc( 0, ((int*)0p)`realloc, align`align, FillT`fill );
	496	test_base(ip, 0, libAlign);
	497	free(ip);
[191a190]	498
	499	if (tests_failed == 0) printf("PASSED alloc tests\n\n");
	500	else printf("failed alloc tests : %d/%d\n\n", tests_failed, tests_total);
	501
	502	// testing alloc (aligned struct)
	503
	504	elemSize = sizeof(T1);
	505	size = dim * elemSize;
	506	last_failed = -1;
	507	tests_total = 0;
	508	tests_failed = 0;
	509
	510	t1p = alloc();
	511	test_base(t1p, elemSize, tAlign);
	512	test_use(t1p, elemSize / elemSize);
	513	free(t1p);
	514
	515	t1p = alloc( dim );
	516	test_base(t1p, size, tAlign);
	517	test_use(t1p, size / elemSize);
	518	free(t1p);
	519
	520	t1p = alloc( 0 );
	521	test_base(t1p, 0, libAlign);
	522	free(t1p);
	523
	524	dp = alloc( dim );
	525	t1p = alloc( dp`resize );
	526	test_base(t1p, elemSize, tAlign);
	527	test_use(t1p, elemSize / elemSize);
	528	free(t1p);
	529
	530	t1p = alloc( ((double*)0p)`resize );
	531	test_base(t1p, elemSize, tAlign);
	532	test_use(t1p, elemSize / elemSize);
	533	free(t1p);
	534
	535	dp = alloc( dim );
	536	t1p = alloc( dim, dp`resize );
	537	test_base(t1p, size, tAlign);
	538	test_use(t1p, size / elemSize);
	539	free(t1p);
	540
	541	dp = alloc( dim );
	542	t1p = alloc( 0, dp`resize );
	543	test_base(t1p, 0, libAlign);
	544	free(t1p);
	545
	546	t1p = alloc( dim, ((double*)0p)`resize );
	547	test_base(t1p, size, tAlign);
	548	test_use(t1p, size / elemSize);
	549	free(t1p);
	550
	551	t1p = alloc( 0, ((double*)0p)`resize );
	552	test_base(t1p, 0, libAlign);
	553	free(t1p);
	554
	555	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	556	t1p = alloc( dim, t1op`realloc );
	557	test_base(t1p, size, tAlign);
	558	test_fill(t1p, 0, dim, (T1){0xdeadbeef});
	559	test_use(t1p, size / elemSize);
	560	free(t1p);
	561
	562	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	563	t1p = alloc( 0, t1op`realloc );
	564	test_base(t1p, 0, libAlign);
	565	free(t1p);
	566
	567	t1p = alloc( dim, ((T1*)0p)`realloc );
	568	test_base(t1p, size, tAlign);
	569	test_use(t1p, size / elemSize);
	570	free(t1p);
	571
	572	t1p = alloc( 0, ((T1*)0p)`realloc );
	573	test_base(t1p, 0, libAlign);
	574	free(t1p);
	575
	576	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	577	t1p = alloc( dim, t1op`resize );
	578	test_base(t1p, size, tAlign);
	579	test_use(t1p, size / elemSize);
	580	free(t1p);
	581
	582	t1p = alloc( FillC`fill );
	583	test_base(t1p, elemSize, tAlign);
	584	test_fill(t1p, 0, elemSize, FillC);
	585	test_use(t1p, elemSize / elemSize);
	586	free(t1p);
	587
	588	t1p = alloc( FillT1`fill );
	589	test_base(t1p, elemSize, tAlign);
	590	test_fill(t1p, 0, 1, FillT1);
	591	test_use(t1p, elemSize / elemSize);
	592	free(t1p);
	593
	594	t1p = alloc( dim, FillC`fill );
	595	test_base(t1p, size, tAlign);
	596	test_fill(t1p, 0, size, FillC);
	597	test_use(t1p, size / elemSize);
	598	free(t1p);
	599
	600	t1p = alloc( 0, FillC`fill );
	601	test_base(t1p, 0, libAlign);
	602	free(t1p);
	603
	604	t1p = alloc( dim, FillT1`fill );
	605	test_base(t1p, size, tAlign);
	606	test_fill(t1p, 0, dim, FillT1);
	607	test_use(t1p, size / elemSize);
	608	free(t1p);
	609
	610	t1p = alloc( 0, FillT1`fill );
	611	test_base(t1p, 0, libAlign);
	612	free(t1p);
	613
	614	t1p = alloc( dim, [FillT1A, dim / 4]`fill );
	615	test_base(t1p, size, tAlign);
	616	test_fill(t1p, 0, size/4, FillT1A);
	617	test_use(t1p, size / elemSize);
	618	free(t1p);
	619
	620	t1p = alloc( 0, [FillT1A, dim / 4]`fill );
	621	test_base(t1p, 0, libAlign);
	622	free(t1p);
	623
	624	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	625	t1p = alloc( dim, t1op`realloc, FillC`fill );
	626	test_base(t1p, size, tAlign);
	627	test_fill(t1p, 0, dim, (T1){0xdeadbeef});
	628	test_use(t1p, size / elemSize);
	629	free(t1p);
	630
	631	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	632	t1p = alloc( dim / 4, t1op`realloc, FillC`fill );
	633	test_base(t1p, size / 4, tAlign);
	634	test_fill(t1p, 0, dim / 4, (T1){0xdeadbeef});
	635	test_use(t1p, size / 4 / elemSize);
	636	free(t1p);
	637
	638	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	639	t1p = alloc( dim * 4, t1op`realloc, FillC`fill );
	640	test_base(t1p, size * 4, tAlign);
	641	test_fill(t1p, 0, dim, (T1){0xdeadbeef});
	642	test_fill(t1p, size, size * 4, FillC);
	643	test_use(t1p, size * 4 / elemSize);
	644	free(t1p);
	645
	646	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	647	t1p = alloc( 0, t1op`realloc, FillC`fill );
	648	test_base(t1p, 0, libAlign);
	649	free(t1p);
	650
	651	t1p = alloc( dim, ((T1*)0p)`realloc, FillC`fill );
	652	test_base(t1p, size, tAlign);
	653	test_fill(t1p, 0, size, FillC);
	654	test_use(t1p, size / elemSize);
	655	free(t1p);
	656
	657	t1p = alloc( 0, ((T1*)0p)`realloc, FillC`fill );
	658	test_base(t1p, 0, libAlign);
	659	free(t1p);
	660
	661	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	662	t1p = alloc( dim, t1op`realloc, FillT1`fill );
	663	test_base(t1p, size, tAlign);
	664	test_fill(t1p, 0, dim, (T1){0xdeadbeef});
	665	test_use(t1p, size / elemSize);
	666	free(t1p);
	667
	668	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	669	t1p = alloc( dim / 4, t1op`realloc, FillT1`fill );
	670	test_base(t1p, size / 4, tAlign);
	671	test_fill(t1p, 0, dim / 4, (T1){0xdeadbeef});
	672	test_use(t1p, size / 4 / elemSize);
	673	free(t1p);
	674
	675	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	676	t1p = alloc( dim * 4, t1op`realloc, FillT1`fill );
	677	test_base(t1p, size * 4, tAlign);
	678	test_fill(t1p, 0, dim, (T1){0xdeadbeef});
	679	test_fill(t1p, dim, dim * 4, FillT1);
	680	test_use(t1p, size * 4 / elemSize);
	681	free(t1p);
	682
	683	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	684	t1p = alloc( 0, t1op`realloc, FillT1`fill );
	685	test_base(t1p, 0, libAlign);
	686	free(t1p);
	687
	688	t1p = alloc( dim, ((T1*)0p)`realloc, FillT1`fill );
	689	test_base(t1p, size, tAlign);
	690	test_fill(t1p, 0, dim, FillT1);
	691	test_use(t1p, size / elemSize);
	692	free(t1p);
	693
[f76ff0b]	694	t1p = alloc( 0, ((T1*)0p)`realloc, FillT1`fill );
	695	test_base(t1p, 0, libAlign);
	696	free(t1p);
[191a190]	697
	698	t1p = alloc( align`align );
	699	test_base(t1p, elemSize, align);
	700	test_use(t1p, elemSize / elemSize);
	701	free(t1p);
	702
	703	t1p = alloc( dim, align`align );
	704	test_base(t1p, size, align);
	705	test_use(t1p, size / elemSize);
	706	free(t1p);
	707
	708	t1p = alloc( 0, align`align );
	709	test_base(t1p, 0, libAlign);
	710	free(t1p);
	711
	712	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	713	t1p = alloc( t1op`realloc, align`align );
	714	test_base(t1p, elemSize, align);
	715	test_fill(t1p, 0, 1, (T1){0xdeadbeef});
	716	test_use(t1p, elemSize / elemSize);
	717	free(t1p);
	718
[f76ff0b]	719	t1p = alloc( ((T1*)0p)`realloc, align`align );
	720	test_base(t1p, elemSize, align);
	721	test_use(t1p, elemSize / elemSize);
	722	free(t1p);
[191a190]	723
	724	dp = alloc( dim );
	725	t1p = alloc( dp`resize, align`align );
	726	test_base(t1p, elemSize, align);
	727	test_use(t1p, elemSize / elemSize);
	728	free(t1p);
	729
[f76ff0b]	730	t1p = alloc( ((double*)0p)`resize, align`align );
	731	test_base(t1p, elemSize, align);
	732	test_use(t1p, elemSize / elemSize);
	733	free(t1p);
[191a190]	734
	735	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	736	t1p = alloc( dim, t1op`realloc, align`align );
	737	test_base(t1p, size, align);
	738	test_fill(t1p, 0, dim, (T1){0xdeadbeef});
	739	test_use(t1p, size / elemSize);
	740	free(t1p);
	741
	742	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	743	t1p = alloc( 0, t1op`realloc, align`align );
	744	test_base(t1p, 0, libAlign);
	745	free(t1p);
	746
[f76ff0b]	747	t1p = alloc( dim, ((T1*)0p)`realloc, align`align );
	748	test_base(t1p, size, align);
	749	test_use(t1p, size / elemSize);
	750	free(t1p);
[191a190]	751
[f76ff0b]	752	t1p = alloc( 0, ((T1*)0p)`realloc, align`align );
	753	test_base(t1p, 0, libAlign);
	754	free(t1p);
[191a190]	755
	756	t1p = alloc( align`align, FillC`fill );
	757	test_base(t1p, elemSize, align);
	758	test_fill(t1p, 0, elemSize, FillC);
	759	test_use(t1p, elemSize / elemSize);
	760	free(t1p);
	761
	762	t1p = alloc( align`align, FillT1`fill );
	763	test_base(t1p, elemSize, align);
	764	test_fill(t1p, 0, 1, FillT1);
	765	test_use(t1p, elemSize / elemSize);
	766	free(t1p);
	767
	768	t1p = alloc( dim, align`align, FillC`fill );
	769	test_base(t1p, size, align);
	770	test_fill(t1p, 0, size, FillC);
	771	test_use(t1p, size / elemSize);
	772	free(t1p);
	773
	774	t1p = alloc( 0, align`align, FillC`fill );
	775	test_base(t1p, 0, libAlign);
	776	free(t1p);
	777
	778	t1p = alloc( dim, align`align, FillT1`fill );
	779	test_base(t1p, size, align);
	780	test_fill(t1p, 0, dim, FillT1);
	781	test_use(t1p, size / elemSize);
	782	free(t1p);
	783
	784	t1p = alloc( 0, align`align, FillT1`fill );
	785	test_base(t1p, 0, libAlign);
	786	free(t1p);
	787
	788	t1p = alloc( dim, align`align, [FillT1A, dim / 4]`fill );
	789	test_base(t1p, size, align);
	790	test_fill(t1p, 0, size/4, FillT1A);
	791	test_use(t1p, size / elemSize);
	792	free(t1p);
	793
	794	t1p = alloc( 0, align`align, [FillT1A, dim / 4]`fill );
	795	test_base(t1p, 0, libAlign);
	796	free(t1p);
	797
	798	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	799	t1p = alloc( dim, t1op`realloc, align`align, FillC`fill );
	800	test_base(t1p, size, align);
	801	test_fill(t1p, 0, dim, (T1){0xdeadbeef});
	802	test_use(t1p, size / elemSize);
	803	free(t1p);
	804
	805	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	806	t1p = alloc( dim / 4, t1op`realloc, align`align, FillC`fill );
	807	test_base(t1p, size / 4, align);
	808	test_fill(t1p, 0, dim / 4, (T1){0xdeadbeef});
	809	test_use(t1p, size / 4 / elemSize);
	810	free(t1p);
	811
	812	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	813	t1p = alloc( dim * 4, t1op`realloc, align`align, FillC`fill );
	814	test_base(t1p, size * 4, align);
	815	test_fill(t1p, 0, dim, (T1){0xdeadbeef});
	816	test_fill(t1p, size, size * 4, FillC);
	817	test_use(t1p, size * 4 / elemSize);
	818	free(t1p);
	819
	820	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	821	t1p = alloc( 0, t1op`realloc, align`align, FillC`fill );
	822	test_base(t1p, 0, libAlign);
	823	free(t1p);
	824
[f76ff0b]	825	t1p = alloc( dim, ((T1*)0p)`realloc, align`align, FillC`fill );
	826	test_base(t1p, size, align);
	827	test_fill(t1p, 0, size, FillC);
	828	test_use(t1p, size / elemSize);
	829	free(t1p);
[191a190]	830
[f76ff0b]	831	t1p = alloc( 0, ((T1*)0p)`realloc, align`align, FillC`fill );
	832	test_base(t1p, 0, libAlign);
	833	free(t1p);
[191a190]	834
	835	t1op = alloc( dim, ((T1){0xdeadbeef})`fill);
	836	t1p = alloc( dim, t1op`realloc, align`align, FillT1`fill );
	837	test_base(t1p, size, align);
	838	test_fill(t1p, 0, dim, (T1){0xdeadbeef});
	839	test_use(t1p, size / elemSize);
	840	free(t1p);
	841
	842	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	843	t1p = alloc( dim / 4, t1op`realloc, align`align, FillT1`fill );
	844	test_base(t1p, size / 4, align);
	845	test_fill(t1p, 0, dim / 4, (T1){0xdeadbeef});
	846	test_use(t1p, size / 4 / elemSize);
	847	free(t1p);
	848
	849	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	850	t1p = alloc( dim * 4, t1op`realloc, align`align, FillT1`fill );
	851	test_base(t1p, size * 4, align);
	852	test_fill(t1p, 0, dim, (T1){0xdeadbeef});
	853	test_fill(t1p, dim, dim * 4, FillT1);
	854	test_use(t1p, size * 4 / elemSize);
	855	free(t1p);
	856
	857	t1op = alloc( dim, ((T1){0xdeadbeef})`fill );
	858	t1p = alloc( 0, t1op`realloc, align`align, FillT1`fill );
	859	test_base(t1p, 0, libAlign);
	860	free(t1p);
	861
[f76ff0b]	862	t1p = alloc( dim, ((T1*)0p)`realloc, align`align, FillT1`fill );
	863	test_base(t1p, size, align);
	864	test_fill(t1p, 0, dim, FillT1);
	865	test_use(t1p, size / elemSize);
	866	free(t1p);
[191a190]	867
[f76ff0b]	868	t1p = alloc( 0, ((T1*)0p)`realloc, align`align, FillT1`fill );
	869	test_base(t1p, 0, libAlign);
	870	free(t1p);
[191a190]	871
	872	if (tests_failed == 0) printf("PASSED alloc tests (aligned struct)\n\n");
	873	else printf("failed alloc tests (aligned struct) : %d/%d\n\n", tests_failed, tests_total);
	874
	875	printf("(if applicable) alignment error below indicates memory trashing caused by test_use.\n\n");
	876	free(FillA);
	877	free(FillT1A);
	878	return 0;
[ea561c9]	879	} // main

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format