Context Navigation

source: tests/alloc2.cfa @ 2e94d94f

ADTast-experimental

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

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

Download in other formats:

Original Format