omtTestError.c
Go to the documentation of this file.
1 #include "omtTest.h"
2 #define OM_CHECK 1
3 #include "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 
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;
47  for (error = omError_MemoryCorrupted; error < omError_MaxError; error++)
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 
74  case omError_NullAddr:
75  {
77  break;
78  }
79 
81  {
82  omDebugAddr((void*) om_MaxAddr);
83  break;
84  }
85 
86  case omError_FalseAddr:
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 
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);
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  {
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);
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  {
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  {
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 
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;
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 
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  {
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  {
421  omDebugMemory();
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 }
void * om_KeptAddr
Definition: omDebug.c:28
const CanonicalForm int s
Definition: facAbsFact.cc:55
void omMergeStickyBinIntoBin(omBin sticky_bin, omBin into_bin)
Definition: omBin.c:396
#define omDebugMemory()
Definition: omAllocDecl.h:318
enum omError_e omError_t
Definition: omError.h:44
int level(const CanonicalForm &f)
omBin_t * omBin
Definition: omStructs.h:12
omMemCell omFindCell(struct LongSpec spec)
Definition: omtTestError.c:15
#define IS_ZERO(spec)
Definition: omtTest.h:55
int NoTrack
Definition: omtTestError.c:11
omBin_t om_StaticBin[]
#define omGetTopBinOfAddr(addr)
#define DO_CHECK(spec)
Definition: omtTest.h:64
size_t omSizeOfAddr(const void *addr)
Definition: omAllocSystem.c:97
#define omListLast(ptr)
Definition: omList.h:64
#define DO_TRACK(spec)
Definition: omtTest.h:71
#define OM_MAX_BIN_INDEX
Definition: omTables.h:4
static poly last
Definition: hdegree.cc:1077
int NotZero
Definition: omtTestError.c:12
void error(const char *fmt,...)
Definition: emacs.cc:58
void InitCellAddrContent(omMemCell cell)
Definition: omtTest.c:134
omError_t om_InternalErrorStatus
Definition: omError.c:12
#define omDebugAddrSize(addr, size)
Definition: omAllocDecl.h:313
int omtTestErrors()
Definition: omtTestError.c:36
#define omCheckList(ptr, level, report, OM_FLR_VAL)
Definition: omList.h:83
#define omIsTrackAddr(addr)
Definition: omDebug.h:12
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define GET_SIZE(spec)
Definition: omtTest.h:52
#define omCheckSortedList(ptr, what, level, report, OM_FLR_VAL)
Definition: omList.h:85
omOpts_t om_Opts
Definition: omOpts.c:11
#define omDebugBinAddrSize(addr, size)
Definition: omAllocDecl.h:312
#define omDebugBinAddr(addr)
Definition: omAllocDecl.h:310
int MaxSize
Definition: omtTestError.c:7
omSpecBin om_SpecBin
Definition: om_Alloc.c:18
#define omFree(addr)
Definition: omAllocDecl.h:261
omError_t om_ErrorStatus
Definition: omError.c:11
#define GET_TRACK(spec)
Definition: omtTest.h:72
#define omAssume(x)
Definition: omError.h:85
const char * omError2Serror(omError_t error)
Definition: omError.c:63
omBinPage_t * omBinPage
Definition: omStructs.h:16
omBinPageRegion_t * omBinPageRegion
Definition: omStructs.h:20
int MinTrack
Definition: omtTestError.c:9
int i
Definition: cfEzgcd.cc:123
#define omGetBinPageOfAddr(addr)
Definition: omBinPage.h:22
void omtTestDebug(omMemCell cell)
Definition: omtTest.c:34
#define OM_MAX_BLOCK_SIZE
Definition: omTables.c:31
void * omAddr_2_OutAddr(void *addr)
#define NULL
Definition: omList.c:10
#define MAX_CELLS
Definition: omtTest.h:13
int MinSize
Definition: omtTestError.c:8
void TestAlloc(omMemCell cell, unsigned long spec)
Definition: omtTest.c:186
int NotIsBin
Definition: omtTestError.c:10
void * om_AlwaysKeptAddrs
Definition: omDebug.c:31
omMemCell_t * omMemCell
Definition: omtTest.h:34
#define omDebugAddr(addr)
Definition: omAllocDecl.h:314
#define omDebugBin(bin)
Definition: omAllocDecl.h:317
#define omRealloc(addr, size)
Definition: omAllocDecl.h:225
#define omDebugAddrBin(addr, bin)
Definition: omAllocDecl.h:311
unsigned long om_MaxAddr
Definition: omDebugCheck.c:19
#define omStrDup(s)
Definition: omAllocDecl.h:263
omMemCell_t cells[MAX_CELLS]
Definition: omtTest.c:9