Context Navigation

source: tests/malloc.cfa@ 3bd9508

Visit:

Last change on this file since 3bd9508 was 829821c, checked in by Michael Brooks <mlbrooks@…>, 8 months ago
Fix test suite to run with no warnings on gcc 12, 13, 14
Property mode set to `100644`
File size: 13.2 KB

Rev	Line
[116a2ea]	1	#include <fstream.hfa> // sout
[191a190]	2	#include <malloc.h> // malloc_usable_size
	3	#include <stdint.h> // uintptr_t
	4	#include <stdlib.hfa> // access C malloc, realloc
	5	#include <unistd.h> // getpagesize
	6
	7	int tests_total;
	8	int tests_failed;
	9	size_t tAlign = 32;
[116a2ea]	10	struct S1 { int data; } __attribute__(( aligned(32)));
[191a190]	11	typedef struct S1 T1;
	12
[116a2ea]	13	void test_base( void * ip, size_t size, size_t align ) {
[191a190]	14	tests_total += 1;
[116a2ea]	15	bool passed = (malloc_size( ip ) == size) && (malloc_usable_size( ip ) >= size) && (malloc_alignment( ip ) == align) && ((uintptr_t)ip % align == 0);
	16	if ( ! passed ) {
	17	sout \| "base failed test" \| tests_total \| "ip" \| ip \| "size" \| size \| "align" \| align \| "but got size" \| malloc_size( ip ) \| "usable" \| malloc_usable_size( ip ) \| "align" \| malloc_alignment( ip );
[191a190]	18	tests_failed += 1;
[116a2ea]	19	} // if
[191a190]	20	}
	21
[116a2ea]	22	void test_fill( void * ip_, size_t start, size_t end, char fill ) {
[191a190]	23	tests_total += 1;
	24	bool passed = true;
	25	char * ip = (char *) ip_;
[116a2ea]	26	for ( i; start ~ end ) passed = passed && (ip[i] == fill);
	27	if ( ! passed ) {
	28	sout \| "fill1 failed test" \| tests_total \| "fill C";
[191a190]	29	tests_failed += 1;
[116a2ea]	30	} // if
[191a190]	31	}
	32
[116a2ea]	33	void test_use( void * ip_ ) {
[191a190]	34	tests_total += 1;
	35	bool passed = true;
	36	int * ip = (int *) ip_;
[116a2ea]	37	size_t size = malloc_size( ip );
	38	for ( i; 0 ~ size ~ sizeof(int)) ip[i/sizeof(int)] = 0xdeadbeef;
	39	for ( i; 0 ~ size ~ sizeof(int)) passed = passed && (ip[i / sizeof(int)] == 0xdeadbeef);
	40	size_t usize = malloc_usable_size( ip );
	41	for ( i; size ~ usize ~ sizeof(int)) ip[i / sizeof(int)] = -1;
	42	for ( i; size ~ usize ~ sizeof(int)) passed = passed && (ip[i / sizeof(int)] == -1);
	43	if ( ! passed ) {
	44	sout \| "failed test" \| tests_total \| "use";
[191a190]	45	tests_failed += 1;
	46	}
	47	}
	48
	49	int main( void ) {
[116a2ea]	50	enum { dim = 8, align = 64, libAlign = libAlign() };
[191a190]	51	size_t elemSize = sizeof(int);
	52	size_t size = dim * elemSize;
	53	int * ip;
	54	T1 * tp;
	55
[116a2ea]	56	// testing C malloc
[191a190]	57
	58	tests_total = 0;
	59	tests_failed = 0;
	60
[116a2ea]	61	ip = (int *)malloc( size );
	62	test_base( ip, size, libAlign );
	63	test_use( ip );
	64	free( ip );
	65
[829821c]	66	#pragma GCC diagnostic push
	67	#pragma GCC diagnostic ignored "-Wpragmas" // -Walloc-size unrecognized until GCC 14
	68	#pragma GCC diagnostic ignored "-Walloc-size"
[116a2ea]	69	ip = (int *)malloc( 0 );
[829821c]	70	#pragma GCC diagnostic pop
[116a2ea]	71	test_base( ip, 0, libAlign );
	72	test_use( ip );
	73	free( ip );
	74
	75	ip = (int *)aalloc( dim, elemSize );
	76	test_base( ip, size, libAlign );
	77	test_use( ip );
	78	free( ip );
	79
	80	ip = (int *)aalloc( 0, elemSize );
	81	test_base( ip, 0, libAlign );
	82	test_use( ip );
	83	free( ip );
	84
	85	ip = (int *)aalloc( dim, 0 );
	86	test_base( ip, 0, libAlign );
	87	test_use( ip );
	88	free( ip );
	89
	90	ip = (int *)aalloc( 0, 0 );
	91	test_base( ip, 0, libAlign );
	92	test_use( ip );
	93	free( ip );
	94
	95	ip = (int *)calloc( dim, elemSize );
	96	test_base( ip, size, libAlign );
	97	test_fill( ip, 0, size, '\0' );
	98	test_use( ip );
	99	free( ip );
	100
	101	ip = (int *)calloc( 0, elemSize );
	102	test_base( ip, 0, libAlign );
	103	test_fill( ip, 0, 0, '\0' );
	104	test_use( ip );
	105	free( ip );
	106
	107	ip = (int *)calloc( dim, 0 );
	108	test_base( ip, 0, libAlign );
	109	test_fill( ip, 0, 0, '\0' );
	110	test_use( ip );
	111	free( ip );
	112
	113	ip = (int *)malloc( size );
	114	ip = (int *)resize( ip, size / 4 );
	115	test_base( ip, size / 4, libAlign );
	116	test_use( ip );
	117	free( ip );
	118
	119	ip = (int *)malloc( size );
	120	ip = (int )resize( ip, size 4 );
	121	test_base( ip, size * 4, libAlign );
	122	test_use( ip );
	123	free( ip );
	124
	125	ip = (int *)malloc( size );
	126	ip = (int *)resize( ip, 0 );
	127	test_base( ip, 0, libAlign );
	128	test_use( ip );
	129	free( ip );
	130
	131	ip = (int *)resize( NULL, size );
	132	test_base( ip, size, libAlign );
	133	test_use( ip );
	134	free( ip );
	135
	136	ip = (int *)resize( 0p, size );
	137	test_base( ip, size, libAlign );
	138	test_use( ip );
	139	free( ip );
	140
	141	ip = (int *)calloc( dim, elemSize );
	142	ip = (int *)realloc( ip, size / 4 );
	143	test_base( ip, size / 4, libAlign );
	144	test_fill( ip, 0, size / 4, '\0' );
	145	test_use( ip );
	146	free( ip );
	147
	148	ip = (int *)calloc( dim, elemSize );
	149	ip = (int )realloc( ip, size 4 );
	150	test_base( ip, size * 4, libAlign );
	151	test_fill( ip, 0, size * 4, '\0' );
	152	test_use( ip );
	153	free( ip );
	154
	155	ip = (int *)calloc( dim, elemSize );
	156	ip = (int *)realloc( ip, 0 );
	157	test_base( ip, 0, libAlign );
	158	test_use( ip );
	159	free( ip );
	160
	161	ip = (int *)realloc( NULL, size );
	162	test_base( ip, size , libAlign );
	163	test_use( ip );
	164	free( ip );
	165
	166	ip = (int *)realloc( 0p, size );
	167	test_base( ip, size, libAlign );
	168	test_use( ip );
	169	free( ip );
	170
	171	ip = (int *)memalign( align, size );
	172	test_base( ip, size, align );
	173	test_use( ip );
	174	free( ip );
	175
	176	ip = (int *)memalign( align, 0 );
	177	test_base( ip, 0, libAlign );
	178	test_use( ip );
	179	free( ip );
	180
	181	ip = (int *)amemalign( align, dim, elemSize );
	182	test_base( ip, size, align );
	183	test_use( ip );
	184	free( ip );
	185
	186	ip = (int *)amemalign( align, 0, elemSize );
	187	test_base( ip, 0, libAlign );
	188	test_use( ip );
	189	free( ip );
	190
	191	ip = (int *)amemalign( align, dim, 0 );
	192	test_base( ip, 0, libAlign );
	193	test_use( ip );
	194	free( ip );
	195
	196	ip = (int *)cmemalign( align, dim, elemSize );
	197	test_base( ip, size, align );
	198	test_fill( ip, 0, size, '\0' );
	199	test_use( ip );
	200	free( ip );
	201
	202	ip = (int *)cmemalign( align, 0, elemSize );
	203	test_base( ip, 0, libAlign );
	204	test_use( ip );
	205	free( ip );
	206
	207	ip = (int *)cmemalign( align, dim, 0 );
	208	test_base( ip, 0, libAlign );
	209	test_use( ip );
	210	free( ip );
	211
	212	ip = (int *)aligned_alloc( align, size );
	213	test_base( ip, size, align );
	214	test_use( ip );
	215	free( ip );
	216
	217	ip = (int *)aligned_alloc( align, 0 );
	218	test_base( ip, 0, libAlign );
	219	test_use( ip );
	220	free( ip );
	221
	222	posix_memalign( (void **) &ip, align, size );
	223	test_base( ip, size, align );
	224	test_use( ip );
	225	free( ip );
	226
	227	posix_memalign( (void **) &ip, align, 0 );
	228	test_base( ip, 0, libAlign );
	229	test_use( ip );
	230	free( ip );
	231
	232	ip = (int *)valloc( size );
	233	test_base( ip, size, getpagesize() );
	234	test_use( ip );
	235	free( ip );
	236
	237	ip = (int *)valloc( 0 );
	238	test_base( ip, 0, libAlign );
	239	test_use( ip );
	240	free( ip );
	241
	242	ip = (int )pvalloc( getpagesize() 3 / 2 );
	243	test_base( ip, getpagesize() * 2, getpagesize() );
	244	test_use( ip );
	245	free( ip );
	246
	247	ip = (int *)pvalloc( 0 );
	248	test_base( ip, 0, libAlign );
	249	test_use( ip );
	250	free( ip );
	251
	252	ip = (int *)malloc( size );
	253	ip = (int *)resize( ip, libAlign, size / 2 );
	254	test_base( ip, size / 2, libAlign );
	255	test_use( ip );
	256	free( ip );
	257
	258	ip = (int *)aligned_alloc( align, size );
	259	ip = (int *)resize( ip, align, size / 2 );
	260	test_base( ip, size / 2, align );
	261	test_use( ip );
	262	free( ip );
	263
	264	ip = (int *)malloc( size );
	265	ip = (int *)resize( ip, align, size / 4 );
	266	test_base( ip, size / 4, align );
	267	test_use( ip );
	268	free( ip );
	269
	270	ip = (int *)malloc( size );
	271	ip = (int *)resize( ip, align, 0 );
	272	test_base( ip, 0, libAlign );
	273	test_use( ip );
	274	free( ip );
	275
	276	ip = (int *)resize( NULL, align, size );
	277	test_base( ip, size, align );
	278	test_use( ip );
	279	free( ip );
	280
	281	ip = (int *)resize( 0p, align, size );
	282	test_base( ip, size, align );
	283	test_use( ip );
	284	free( ip );
	285
	286	ip = (int *)calloc( dim, elemSize );
	287	ip = (int *)realloc( ip, libAlign, size / 2 );
	288	test_base( ip, size / 2, libAlign );
	289	test_fill( ip, 0, size / 2, '\0' );
	290	test_use( ip );
	291	free( ip );
	292
	293	ip = (int *)cmemalign( align, dim, elemSize );
	294	ip = (int *)realloc( ip, align, size / 2 );
	295	test_base( ip, size / 2, align );
	296	test_fill( ip, 0, size / 2, '\0' );
	297	test_use( ip );
	298	free( ip );
	299
	300	ip = (int *)calloc( dim, elemSize );
	301	ip = (int *)realloc( ip, align, size / 4 );
	302	test_base( ip, size / 4, align );
	303	test_fill( ip, 0, size / 4, '\0' );
	304	test_use( ip );
	305	free( ip );
	306
	307	ip = (int *)calloc( dim, elemSize );
	308	ip = (int )realloc( ip, libAlign, size 4 );
	309	test_base( ip, size * 4, libAlign );
	310	test_fill( ip, 0, size * 4, '\0' );
	311	test_use( ip );
	312	free( ip );
	313
	314	ip = (int *)calloc( dim, elemSize );
	315	ip = (int *)realloc( ip, align, 0 );
	316	test_base( ip, 0, libAlign );
	317	test_use( ip );
	318	free( ip );
	319
	320	free( 0p ); // sanity check
	321	free( NULL ); // sanity check
	322
	323	if (tests_failed == 0) sout \| "PASSED C malloc tests" \| nl \| nl;
	324	else sout \| "failed C malloc tests" \| tests_failed \| tests_total \| nl \| nl;
[191a190]	325
	326	// testing CFA malloc
	327
	328	tests_total = 0;
	329	tests_failed = 0;
	330
	331	ip = malloc();
[116a2ea]	332	test_base( ip, elemSize, libAlign );
	333	test_use( ip );
	334	free( ip );
[191a190]	335
	336	ip = aalloc( dim );
[116a2ea]	337	test_base( ip, size, libAlign );
	338	test_use( ip );
	339	free( ip );
[191a190]	340
	341	ip = aalloc( 0 );
[116a2ea]	342	test_base( ip, 0, libAlign );
	343	test_use( ip );
	344	free( ip );
[191a190]	345
	346	ip = calloc( dim );
[116a2ea]	347	test_base( ip, size, libAlign );
	348	test_fill( ip, 0, size, '\0' );
	349	test_use( ip );
	350	free( ip );
[191a190]	351
	352	ip = calloc( 0 );
[116a2ea]	353	test_base( ip, 0, libAlign );
	354	test_use( ip );
	355	free( ip );
[191a190]	356
	357	ip = aalloc( dim );
	358	ip = resize( ip, size / 4 );
[116a2ea]	359	test_base( ip, size / 4, libAlign );
	360	test_use( ip );
	361	free( ip );
[191a190]	362
	363	ip = aalloc( dim );
	364	ip = resize( ip, size * 4 );
[116a2ea]	365	test_base( ip, size * 4, libAlign );
	366	test_use( ip );
	367	free( ip );
[191a190]	368
	369	ip = aalloc( dim );
	370	ip = resize( ip, 0 );
[116a2ea]	371	test_base( ip, 0, libAlign );
	372	test_use( ip );
	373	free( ip );
[191a190]	374
[116a2ea]	375	ip = resize( 0p, size );
	376	test_base( ip, size, libAlign );
	377	test_use( ip );
	378	free( ip );
[191a190]	379
[116a2ea]	380	ip = resize( 0p, size );
	381	test_base( ip, size, libAlign );
	382	test_use( ip );
	383	free( ip );
[191a190]	384
	385	ip = calloc( dim );
	386	ip = realloc( ip, size / 4 );
[116a2ea]	387	test_base( ip, size / 4, libAlign );
	388	test_fill( ip, 0, size / 4, '\0' );
	389	test_use( ip );
	390	free( ip );
[191a190]	391
	392	ip = calloc( dim );
	393	ip = realloc( ip, size * 4 );
[116a2ea]	394	test_base( ip, size * 4, libAlign );
	395	test_fill( ip, 0, size, '\0' );
	396	test_use( ip );
	397	free( ip );
[191a190]	398
	399	ip = calloc( dim );
	400	ip = realloc( ip, 0 );
[116a2ea]	401	test_base( ip, 0, libAlign );
	402	test_use( ip );
	403	free( ip );
[191a190]	404
[116a2ea]	405	ip = realloc( 0p, size );
	406	test_base( ip, size , libAlign );
	407	test_use( ip );
	408	free( ip );
[191a190]	409
[116a2ea]	410	ip = realloc( 0p, size );
	411	test_base( ip, size, libAlign );
	412	test_use( ip );
	413	free( ip );
[191a190]	414
	415	ip = memalign( align );
[116a2ea]	416	test_base( ip, elemSize, align );
	417	test_use( ip );
	418	free( ip );
[191a190]	419
	420	ip = amemalign( align, dim );
[116a2ea]	421	test_base( ip, size, align );
	422	test_use( ip );
	423	free( ip );
[191a190]	424
	425	ip = amemalign( align, 0 );
[116a2ea]	426	test_base( ip, 0, libAlign );
	427	test_use( ip );
	428	free( ip );
[191a190]	429
	430	ip = cmemalign( align, dim );
[116a2ea]	431	test_base( ip, size, align );
	432	test_fill( ip, 0, size, '\0' );
	433	test_use( ip );
	434	free( ip );
[191a190]	435
	436	ip = cmemalign( align, 0 );
[116a2ea]	437	test_base( ip, 0, libAlign );
	438	test_use( ip );
	439	free( ip );
[191a190]	440
	441	ip = aligned_alloc( align );
[116a2ea]	442	test_base( ip, elemSize, align );
	443	test_use( ip );
	444	free( ip );
[191a190]	445
[116a2ea]	446	posix_memalign( (int **) &ip, align );
	447	test_base( ip, elemSize, align );
	448	test_use( ip );
	449	free( ip );
[191a190]	450
	451	ip = valloc();
[116a2ea]	452	test_base( ip, elemSize, getpagesize() );
	453	test_use( ip );
	454	free( ip );
[191a190]	455
	456	ip = pvalloc();
[116a2ea]	457	test_base( ip, getpagesize(), getpagesize() );
	458	test_use( ip );
	459	free( ip );
[191a190]	460
[116a2ea]	461	if (tests_failed == 0) sout \| "PASSED CFA malloc tests" \| nl \| nl;
	462	else sout \| "failed CFA malloc tests" \| tests_failed \| tests_total \| nl \| nl;
[191a190]	463
[f76ff0b]	464	// testing CFA malloc with aligned struct
[191a190]	465
	466	elemSize = sizeof(T1);
	467	size = dim * elemSize;
	468	tests_total = 0;
	469	tests_failed = 0;
	470
	471	tp = malloc();
[116a2ea]	472	test_base( tp, elemSize, tAlign );
	473	test_use( tp );
	474	free( tp );
[191a190]	475
	476	tp = aalloc( dim );
[116a2ea]	477	test_base( tp, size, tAlign );
	478	test_use( tp );
	479	free( tp );
[191a190]	480
	481	tp = aalloc( 0 );
[116a2ea]	482	test_base( tp, 0, libAlign );
	483	test_use( tp );
	484	free( tp );
[191a190]	485
	486	tp = calloc( dim );
[116a2ea]	487	test_base( tp, size, tAlign );
	488	test_fill( tp, 0, size, '\0' );
	489	test_use( tp );
	490	free( tp );
[191a190]	491
	492	tp = calloc( 0 );
[116a2ea]	493	test_base( tp, 0, libAlign );
	494	test_use( tp );
	495	free( tp );
[191a190]	496
	497	tp = aalloc( dim );
	498	tp = resize( tp, size / 4 );
[116a2ea]	499	test_base( tp, size / 4, tAlign );
	500	test_use( tp );
	501	free( tp );
[191a190]	502
	503	tp = malloc();
	504	tp = resize( tp, size * 4 );
[116a2ea]	505	test_base( tp, size * 4, tAlign );
	506	test_use( tp );
	507	free( tp );
[191a190]	508
	509	tp = aalloc( dim );
	510	tp = resize( tp, 0 );
[116a2ea]	511	test_base( tp, 0, libAlign );
	512	test_use( tp );
	513	free( tp );
[191a190]	514
[68f0c4e]	515	tp = resize( (T1*)0p, size );
[116a2ea]	516	test_base( tp, size, tAlign );
	517	test_use( tp );
	518	free( tp );
[191a190]	519
[68f0c4e]	520	tp = resize( (T1*)0p, size );
[116a2ea]	521	test_base( tp, size, tAlign );
	522	test_use( tp );
	523	free( tp );
[191a190]	524
	525	tp = calloc( dim );
	526	tp = realloc( tp, size / 4 );
[116a2ea]	527	test_base( tp, size / 4, tAlign );
	528	test_fill( tp, 0, size / 4, '\0' );
	529	test_use( tp );
	530	free( tp );
[191a190]	531
	532	tp = calloc( dim );
	533	tp = realloc( tp, size * 4 );
[116a2ea]	534	test_base( tp, size * 4, tAlign );
	535	test_fill( tp, 0, size, '\0' );
	536	test_use( tp );
	537	free( tp );
[191a190]	538
	539	tp = calloc( dim );
	540	tp = realloc( tp, 0 );
[116a2ea]	541	test_base( tp, 0, libAlign );
	542	test_use( tp );
	543	free( tp );
[191a190]	544
[68f0c4e]	545	tp = realloc( (T1*)0p, size );
[116a2ea]	546	test_base( tp, size , tAlign );
	547	test_use( tp );
	548	free( tp );
[191a190]	549
[68f0c4e]	550	tp = realloc( (T1*)0p, size );
[116a2ea]	551	test_base( tp, size, tAlign );
	552	test_use( tp );
	553	free( tp );
[191a190]	554
	555	tp = memalign( align );
[116a2ea]	556	test_base( tp, elemSize, align );
	557	test_use( tp );
	558	free( tp );
[191a190]	559
	560	tp = amemalign( align, dim );
[116a2ea]	561	test_base( tp, size, align );
	562	test_use( tp );
	563	free( tp );
[191a190]	564
	565	tp = amemalign( align, 0 );
[116a2ea]	566	test_base( tp, 0, libAlign );
	567	test_use( tp );
	568	free( tp );
[191a190]	569
	570	tp = cmemalign( align, dim );
[116a2ea]	571	test_base( tp, size, align );
	572	test_fill( tp, 0, size, '\0' );
	573	test_use( tp );
	574	free( tp );
[191a190]	575
	576	tp = cmemalign( align, 0 );
[116a2ea]	577	test_base( tp, 0, libAlign );
	578	test_use( tp );
	579	free( tp );
[191a190]	580
	581	tp = aligned_alloc( align );
[116a2ea]	582	test_base( tp, elemSize, align );
	583	test_use( tp );
	584	free( tp );
[191a190]	585
[116a2ea]	586	posix_memalign( (T1 **)&tp, align );
	587	test_base( tp, elemSize, align );
	588	test_use( tp );
	589	free( tp );
[191a190]	590
	591	tp = valloc();
[116a2ea]	592	test_base( tp, elemSize, getpagesize() );
	593	test_use( tp );
	594	free( tp );
[191a190]	595
	596	tp = pvalloc();
[116a2ea]	597	test_base( tp, getpagesize(), getpagesize() );
	598	test_use( tp );
	599	free( tp );
[191a190]	600
[116a2ea]	601	if ( tests_failed == 0 ) sout \| "PASSED CFA malloc tests (aligned struct)" \| nl \| nl;
	602	else sout \| "failed CFA malloc tests (aligned struct)" \| tests_failed \| tests_total \| nl \| nl;
[f8acfc0]	603	}
[654d5a47]	604
	605	// Local Variables: //
	606	// tab-width: 4 //
	607	// compile-command: "cfa malloc.cfa" //
	608	// End: //

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

Download in other formats:

Original Format