Context Navigation

source: git/omalloc/omtTestError.c @ b335e35

fieker-DuValspielwiese

Last change on this file since b335e35 was bd8655a, checked in by Hans Schoenemann <hannes@…>, 3 years ago
dummy 'make check' for xalloc
Property mode set to `100644`
File size: 11.4 KB

Line
1	#include "omtTest.h"
2	#define OM_CHECK 1
3	#include "omalloc.h"
4
5	#ifdef HAVE_OMALLOC
6	struct LongSpec
7	{
8	int MaxSize;
9	int MinSize;
10	int MinTrack;
11	int NotIsBin;
12	int NoTrack;
13	int NotZero;
14	};
15
16	omMemCell omFindCell(struct LongSpec spec)
17	{
18	int i;
19	for (i=0; i<MAX_CELLS; i++)
20	{
21	if ((cells[i].addr != NULL) &&
22	(spec.MinTrack == 0 \|\| (DO_CHECK(cells[i].spec) &&
23	DO_TRACK(cells[i].spec) &&
24	GET_TRACK(cells[i].spec) >= spec.MinTrack)) &&
25	(spec.MinSize == 0 \|\| GET_SIZE(cells[i].spec) >= spec.MinSize) &&
26	(spec.MaxSize == 0 \|\| GET_SIZE(cells[i].spec) <= spec.MaxSize) &&
27	(spec.NotIsBin == 0 \|\| cells[i].bin == NULL) &&
28	(spec.NotZero == 0 \|\| !IS_ZERO(cells[i].spec)) &&
29	(spec.NoTrack == 0 \|\| !DO_CHECK(cells[i].spec) \|\| !DO_TRACK(cells[i].spec)))
30	{
31	return &cells[i];
32	}
33	}
34	return NULL;
35	}
36
37	int omtTestErrors()
38	{
39	#ifndef OM_NDEBUG
40	int level = om_Opts.MinCheck;
41	omError_t error;
42	struct LongSpec spec;
43	int missed = 0, alloc;
44	omMemCell cell = NULL;
45
46	printf("omtTestErrors: Start\n");
47	om_Opts.MinCheck = 2;
48	for (error = omError_MemoryCorrupted; error < omError_MaxError; error++)
49	{
50	om_InternalErrorStatus = omError_NoError;
51	om_ErrorStatus = omError_NoError;
52	printf("!!!expect %s\n", omError2Serror(error));
53	memset(&spec, 0, sizeof(struct LongSpec));
54	cell = NULL;
55	alloc = 0;
56	switch (error)
57	{
58	case omError_MemoryCorrupted:
59	{
60	spec.MaxSize = OM_MAX_BLOCK_SIZE;
61	cell = omFindCell(spec);
62	if (cell != NULL)
63	{
64	omBin bin = omGetTopBinOfAddr(cell->addr);
65	omBinPage last_page = bin->last_page;
66	omAssume(last_page != NULL);
67	bin->last_page = NULL;
68	omDebugBin(cell->bin);
69	bin->last_page = last_page;
70	}
71	else printf("cell not found\n");
72	break;
73	}
74
75	case omError_NullAddr:
76	{
77	omDebugAddr(NULL);
78	break;
79	}
80
81	case omError_InvalidRangeAddr:
82	{
83	omDebugAddr((void*) om_MaxAddr);
84	break;
85	}
86
87	case omError_FalseAddr:
88	{
89	spec.MinSize = 8;
90	spec.MaxSize = OM_MAX_BLOCK_SIZE;
91	spec.NoTrack = 1;
92	cell = omFindCell(spec);
93	if (cell != NULL)
94	{
95	omDebugAddr(cell->addr + SIZEOF_VOIDP);
96	}
97	else printf("cell not found\n");
98	break;
99	}
100
101	case omError_FalseAddrOrMemoryCorrupted:
102	{
103	spec.MinSize = 8;
104	spec.MinTrack = 3;
105	cell = omFindCell(spec);
106	if (cell != NULL)
107	{
108	omDebugAddr(cell->addr + SIZEOF_VOIDP);
109	}
110	else printf("cell not found\n");
111	break;
112	}
113
114	case omError_WrongSize:
115	{
116	spec.MaxSize = OM_MAX_BLOCK_SIZE;
117	cell = omFindCell(spec);
118	if (cell != NULL)
119	{
120	omDebugAddrSize(cell->addr, OM_MAX_BLOCK_SIZE + 1);
121	if (om_ErrorStatus != omError_NoError)
122	{
123	om_ErrorStatus = omError_NoError;
124	spec.MaxSize = 0;
125	spec.MinTrack = 3;
126	spec.NotIsBin = 1;
127	spec.MinSize = 2;
128	cell = omFindCell(spec);
129	if (cell != NULL)
130	{
131	omDebugAddrSize(cell->addr, GET_SIZE(cell->spec) + SIZEOF_OM_ALIGNMENT);
132	if (om_ErrorStatus != omError_NoError)
133	{
134	om_ErrorStatus = omError_NoError;
135	spec.MaxSize = OM_MAX_BLOCK_SIZE;
136	spec.MinTrack = 0;
137	spec.NotIsBin = 0;
138	cell = omFindCell(spec);
139	if (cell != NULL)
140	omDebugBinAddrSize(cell->addr, GET_SIZE(cell->spec) - 1);
141	else printf("cell not found");
142	}
143	}
144	else printf("cell not found\n");
145	}
146	}
147	else printf("cell not found\n");
148	break;
149	}
150
151	case omError_FreedAddr:
152	{
153	#if KEEP_LEVEL > 0
154	void* addr = om_AlwaysKeptAddrs;
155	while (addr != NULL && omIsTrackAddr(addr))
156	{
157	addr = ((void*) addr);
158	}
159	if (addr != NULL)
160	{
161	omFree(addr);
162	if (om_ErrorStatus == omError_FreedAddr)
163	{
164	om_ErrorStatus = omError_NoError;
165	addr = om_AlwaysKeptAddrs;
166	while (addr != NULL && ! omIsTrackAddr(addr))
167	{
168	addr = ((void*) addr);
169	}
170	if (addr != NULL)
171	{
172	addr = omAddr_2_OutAddr(addr);
173	omFree(addr);
174	}
175	}
176	}
177	if (addr == NULL)
178	{
179	printf("addr not found\n");
180	break;
181	}
182	if (om_ErrorStatus != omError_FreedAddr)
183	break;
184	#endif
185	spec.MinTrack = 5;
186	spec.NotIsBin = 1;
187	cell = omFindCell(spec);
188	if (cell != NULL)
189	{
190	omFree(cell->addr);
191	omFree(cell->addr);
192	alloc = 1;
193	cell->addr=NULL;
194	}
195	else printf("cell not found\n");
196	break;
197	}
198
199	case omError_FreedAddrOrMemoryCorrupted:
200	{
201	spec.MaxSize = OM_MAX_BLOCK_SIZE;
202	spec.NoTrack = 1;
203	cell = omFindCell(spec);
204	if (cell != NULL)
205	{
206	omBinPage page = omGetBinPageOfAddr(cell->addr);
207	omBinPageRegion region = page->region;
208	page->region = NULL;
209	om_Opts.MinCheck = 1;
210	omDebugAddr(cell->addr);
211	om_Opts.MinCheck = 2;
212	page->region = region;
213	}
214	else printf("cell not found\n");
215	break;
216	}
217
218	case omError_WrongBin:
219	{
220	spec.MaxSize = 32;
221	spec.NoTrack = 1;
222	cell = omFindCell(spec);
223	if (cell != NULL)
224	{
225	omDebugAddrBin(cell->addr, &om_StaticBin[OM_MAX_BIN_INDEX]);
226	}
227	else printf("cell not found\n");
228	break;
229	}
230
231	case omError_UnknownBin:
232	{
233	spec.MaxSize = OM_MAX_BLOCK_SIZE;
234	cell = omFindCell(spec);
235	if (cell != NULL)
236	{
237	omDebugAddrBin(cell->addr, (void*) omGetTopBinOfAddr(cell->addr) + SIZEOF_VOIDP);
238	}
239	else printf("cell not found\n");
240	break;
241	}
242
243	case omError_NotBinAddr:
244	{
245	spec.NotIsBin = 1;
246	spec.MinSize = OM_MAX_BLOCK_SIZE + 1;
247	cell = omFindCell(spec);
248	if (cell != NULL)
249	{
250	omDebugBinAddr(cell->addr);
251	}
252	else printf("cell not found");
253	break;
254	}
255
256	case omError_UnalignedAddr:
257	{
258	cell = omFindCell(spec);
259	if (cell != NULL)
260	{
261	omDebugAddr(cell->addr + 1);
262	}
263	else printf("cell not found\n");
264	break;
265	}
266
267	case omError_NullSizeAlloc:
268	{
269	void* addr = omAlloc(0);
270	addr = omRealloc(addr, 0);
271	omFree(addr);
272	break;
273	}
274
275	case omError_ListCycleError:
276	{
277	void* last = omListLast(om_SpecBin);
278	if (last != NULL)
279	{
280	((void*)last) = om_SpecBin;
281	omCheckList(om_SpecBin, 5, omError_NoError, OM_FLR);
282	((void*)last) = NULL;
283	} else printf("last == NULL\n");
284	break;
285	}
286
287	case omError_SortedListError:
288	{
289	if (om_SpecBin != NULL && om_SpecBin->next != NULL)
290	{
291	int max_blocks = om_SpecBin->max_blocks;
292	om_SpecBin->max_blocks = om_SpecBin->next->max_blocks + 1;
293	omCheckSortedList(om_SpecBin, max_blocks, 5, omError_NoError, OM_FLR);
294	om_SpecBin->max_blocks = max_blocks;
295	} else printf("om_SpecBin->next == NULL\n");
296	break;
297	}
298
299	case omError_KeptAddrListCorrupted:
300	{
301	if (om_KeptAddr != NULL)
302	{
303	void* last = omListLast(om_KeptAddr);
304	((void*)last) = om_KeptAddr;
305	om_Opts.MinCheck = 5;
306	omDebugMemory();
307	om_Opts.MinCheck = 2;
308	((void*)last) = NULL;
309	}
310	else printf("om_KeptAddr == NULL\n");
311	break;
312	}
313
314	case omError_FreePattern:
315	{
316	if (om_Opts.Keep > 0)
317	{
318	spec.MinTrack=3;
319	spec.NotIsBin = 1;
320	cell = omFindCell(spec);
321	if (cell != NULL)
322	{
323	void* value;
324	omFree(cell->addr);
325	value = ((void*) cell->addr);
326	((void*) cell->addr) = value -1;
327	omDebugMemory();
328	((void*) cell->addr) = value;
329	alloc = 1;
330	cell->addr = NULL;
331	}
332	else printf("cell not found\n");
333	}
334	else printf("om_Opts.Keep == 0");
335	break;
336	}
337
338	case omError_BackPattern:
339	{
340	spec.MinTrack = 3;
341	spec.NotIsBin = 1;
342	cell = omFindCell(spec);
343	if (cell != NULL)
344	{
345	void* addr = cell->addr + omSizeOfAddr(cell->addr);
346	void* value = ((void*) addr);
347	((void*) addr) = value -1;
348	omDebugAddr(cell->addr);
349	((void*) addr) = value;
350	}
351	else printf("cell not found\n");
352	break;
353	}
354
355	case omError_FrontPattern:
356	{
357	spec.MinTrack=3;
358	cell = omFindCell(spec);
359	if (cell != NULL)
360	{
361	void* addr = cell->addr - SIZEOF_VOIDP;
362	void* value = ((void*) addr);
363	((void*) addr) = value -1;
364	omDebugAddr(cell->addr);
365	((void*) addr) = value;
366	}
367	else printf("cell not found\n");
368	break;
369	}
370
371	case omError_NotString:
372	{
373	/* can only test for NULL string */
374	#if 0
375	spec.MaxSize = OM_MAX_BLOCK_SIZE;
376	cell = omFindCell(spec);
377	if (cell != NULL)
378	{
379	char* addr = (char*) cell->addr;
380	char* s;
381	memset(cell->addr, 1, omSizeOfAddr(cell->addr));
382	omDebugAddr(cell->addr);
383	s = omStrDup(addr);
384	omFree(s);
385	InitCellAddrContent(cell);
386	}
387	else printf("cell not found\n");
388	break;
389	#endif
390	omStrDup(NULL);
391	break;
392	}
393
394	case omError_StickyBin:
395	{
396	omMergeStickyBinIntoBin(NULL, NULL);
397	break;
398	}
399
400	default:
401	printf("No Error test implemented\n");
402	}
403
404	if (om_ErrorStatus != error)
405	{
406	printf("---missed %s\n", omError2Serror(error));
407	missed++;
408	}
409	else
410	{
411	printf("+++ok %s\n", omError2Serror(error));
412	}
413
414	om_ErrorStatus = omError_NoError;
415	if (cell != NULL)
416	{
417	if (alloc) TestAlloc(cell, cell->spec);
418	omtTestDebug(cell);
419	}
420	else
421	{
422	omDebugMemory();
423	}
424	if (om_ErrorStatus != omError_NoError)
425	{
426	printf("omtTest panik: memory corrupted\n\n");
427	return -1;
428	}
429	printf("\n");
430	}
431	printf("omtTestErrors: Summary: missed = %d\n\n", missed);
432	om_Opts.MinCheck = level;
433	return missed;
434	#else
435	return 0;
436	#endif
437	}
438	#endif

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

Download in other formats: