Context Navigation

source: tests/malloc.cfa @ fd5d251

Last change on this file since fd5d251 was 10b5970, checked in by Michael Brooks <mlbrooks@…>, 4 weeks ago

Fix many test-suite- and libcfa-caused unused variable warnings.

In scope are easy fixes among tests whose sole warnings were unused variable. Reduces the wflags lax list by 40%.

Property mode set to 100644

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

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

Download in other formats:

Original Format