My Project
omtTestError.c
Go to the documentation of this file.
1#include "omtTest.h"
2#define OM_CHECK 1
3#include "omalloc.h"
4
5struct LongSpec
6{
7 int MaxSize;
8 int MinSize;
13};
14
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
37{
38#ifndef OM_NDEBUG
39 int level = om_Opts.MinCheck;
41 struct LongSpec spec;
42 int missed = 0, alloc;
43 omMemCell cell = NULL;
44
45 printf("omtTestErrors: Start\n");
46 om_Opts.MinCheck = 2;
48 {
51 printf("!!!expect %s\n", omError2Serror(error));
52 memset(&spec, 0, sizeof(struct LongSpec));
53 cell = NULL;
54 alloc = 0;
55 switch (error)
56 {
58 {
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
75 {
77 break;
78 }
79
81 {
82 omDebugAddr((void*) om_MaxAddr);
83 break;
84 }
85
87 {
88 spec.MinSize = 8;
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
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
114 {
116 cell = omFindCell(spec);
117 if (cell != NULL)
118 {
119 omDebugAddrSize(cell->addr, OM_MAX_BLOCK_SIZE + 1);
121 {
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);
132 {
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
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);
162 {
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 }
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
199 {
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 {
225 }
226 else printf("cell not found\n");
227 break;
228 }
229
231 {
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
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
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
267 {
268 void* addr = omAlloc(0);
269 addr = omRealloc(addr, 0);
270 omFree(addr);
271 break;
272 }
273
275 {
276 void* last = omListLast(om_SpecBin);
277 if (last != NULL)
278 {
279 *((void**)last) = om_SpecBin;
281 *((void**)last) = NULL;
282 } else printf("last == NULL\n");
283 break;
284 }
285
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
299 {
300 if (om_KeptAddr != NULL)
301 {
302 void* last = omListLast(om_KeptAddr);
303 *((void**)last) = om_KeptAddr;
304 om_Opts.MinCheck = 5;
306 om_Opts.MinCheck = 2;
307 *((void**)last) = NULL;
308 }
309 else printf("om_KeptAddr == NULL\n");
310 break;
311 }
312
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;
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
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
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
371 {
372/* can only test for NULL string */
373#if 0
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);
385 }
386 else printf("cell not found\n");
387 break;
388#endif
389 omStrDup(NULL);
390 break;
391 }
392
394 {
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
414 if (cell != NULL)
415 {
416 if (alloc) TestAlloc(cell, cell->spec);
417 omtTestDebug(cell);
418 }
419 else
420 {
422 }
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}
#define NULL
Definition: auxiliary.h:104
int level(const CanonicalForm &f)
int i
Definition: cfEzgcd.cc:132
void error(const char *fmt,...)
Definition: emacs.cc:55
const CanonicalForm int s
Definition: facAbsFact.cc:51
STATIC_VAR poly last
Definition: hdegree.cc:1150
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omDebugMemory()
Definition: omAllocDecl.h:318
#define omDebugBinAddrSize(addr, size)
Definition: omAllocDecl.h:312
#define omDebugAddr(addr)
Definition: omAllocDecl.h:314
#define omDebugBinAddr(addr)
Definition: omAllocDecl.h:310
#define omRealloc(addr, size)
Definition: omAllocDecl.h:225
#define omDebugAddrSize(addr, size)
Definition: omAllocDecl.h:313
#define omFree(addr)
Definition: omAllocDecl.h:261
#define omDebugBin(bin)
Definition: omAllocDecl.h:317
#define omDebugAddrBin(addr, bin)
Definition: omAllocDecl.h:311
#define omGetTopBinOfAddr(addr)
omBin_t om_StaticBin[]
size_t omSizeOfAddr(const void *addr)
#define omGetBinPageOfAddr(addr)
Definition: omBinPage.h:22
void * om_AlwaysKeptAddrs
Definition: omDebug.c:31
void * om_KeptAddr
Definition: omDebug.c:28
unsigned long om_MaxAddr
Definition: omDebugCheck.c:19
void * omAddr_2_OutAddr(void *addr)
#define omIsTrackAddr(addr)
Definition: omDebug.h:12
omError_t om_ErrorStatus
Definition: omError.c:13
const char * omError2Serror(omError_t error)
Definition: omError.c:65
omError_t om_InternalErrorStatus
Definition: omError.c:14
#define omAssume(x)
Definition: omError.h:85
@ omError_WrongSize
Definition: omError.h:26
@ omError_ListCycleError
Definition: omError.h:34
@ omError_BackPattern
Definition: omError.h:38
@ omError_NullAddr
Definition: omError.h:22
@ omError_NullSizeAlloc
Definition: omError.h:33
@ omError_MaxError
Definition: omError.h:42
@ omError_FrontPattern
Definition: omError.h:39
@ omError_UnalignedAddr
Definition: omError.h:32
@ omError_MemoryCorrupted
Definition: omError.h:21
@ omError_FreedAddr
Definition: omError.h:27
@ omError_UnknownBin
Definition: omError.h:30
@ omError_FreedAddrOrMemoryCorrupted
Definition: omError.h:28
@ omError_NotString
Definition: omError.h:40
@ omError_SortedListError
Definition: omError.h:35
@ omError_KeptAddrListCorrupted
Definition: omError.h:36
@ omError_NotBinAddr
Definition: omError.h:31
@ omError_InvalidRangeAddr
Definition: omError.h:23
@ omError_FalseAddr
Definition: omError.h:24
@ omError_WrongBin
Definition: omError.h:29
@ omError_NoError
Definition: omError.h:18
@ omError_StickyBin
Definition: omError.h:41
@ omError_FreePattern
Definition: omError.h:37
@ omError_FalseAddrOrMemoryCorrupted
Definition: omError.h:25
enum omError_e omError_t
Definition: omError.h:44
#define omCheckSortedList(ptr, what, level, report, OM_FLR_VAL)
Definition: omList.h:85
#define omListLast(ptr)
Definition: omList.h:64
#define omCheckList(ptr, level, report, OM_FLR_VAL)
Definition: omList.h:83
omOpts_t om_Opts
Definition: omOpts.c:13
omBinPage_t * omBinPage
Definition: omStructs.h:16
omBin_t * omBin
Definition: omStructs.h:12
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
#define OM_MAX_BLOCK_SIZE
Definition: omTables.c:31
#define OM_MAX_BIN_INDEX
Definition: omTables.h:4
omSpecBin om_SpecBin
Definition: om_Alloc.c:20
int MinSize
Definition: omtTestError.c:8
omMemCell omFindCell(struct LongSpec spec)
Definition: omtTestError.c:15
int MaxSize
Definition: omtTestError.c:7
int NotZero
Definition: omtTestError.c:12
int NotIsBin
Definition: omtTestError.c:10
int NoTrack
Definition: omtTestError.c:11
int MinTrack
Definition: omtTestError.c:9
int omtTestErrors()
Definition: omtTestError.c:36
void TestAlloc(omMemCell cell, unsigned long spec)
Definition: omtTest.c:186
omMemCell_t cells[MAX_CELLS]
Definition: omtTest.c:9
void omtTestDebug(omMemCell cell)
Definition: omtTest.c:34
void InitCellAddrContent(omMemCell cell)
Definition: omtTest.c:134
#define GET_TRACK(spec)
Definition: omtTest.h:72
#define IS_ZERO(spec)
Definition: omtTest.h:55
omMemCell_t * omMemCell
Definition: omtTest.h:34
#define DO_CHECK(spec)
Definition: omtTest.h:64
#define GET_SIZE(spec)
Definition: omtTest.h:52
#define DO_TRACK(spec)
Definition: omtTest.h:71
#define MAX_CELLS
Definition: omtTest.h:13
#define omMergeStickyBinIntoBin(A, B)
Definition: xalloc.h:323