Context Navigation

source: git/omalloc/omtTestError.c @ 85bcd6

spielwiese

Last change on this file since 85bcd6 was f769719, checked in by Mohamed Barakat <mohamed.barakat@…>, 13 years ago
- we all got rid of makeheader (sorry Hans ;( ) . renamed: om_Alloc.h -> omalloc.h - updated Makefile.am to install the public header files - fixed the VERSION string issue - got rid of the obsolete path stuff (Oleksandr is happier now)
Property mode set to `100644`
File size: 11.4 KB

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

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

Download in other formats: