source: git/omalloc/omtTestError.c @ 4697a8a

fieker-DuValspielwiese
Last change on this file since 4697a8a was e70e45, checked in by Olaf Bachmann <obachman@…>, 24 years ago
* re-added files git-svn-id: file:///usr/local/Singular/svn/trunk@4521 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 9.3 KB
Line 
1#include "omtTest.h"
2#define OM_CHECK 1
3#include "omAlloc.h"
4
5struct LongSpec
6{
7  int MaxSize;
8  int MinSize;
9  int MinTrack;
10  int NotIsBin;
11  int NoTrack;
12  int NotZero;
13};
14
15omMemCell 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
36int 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 = 5;
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            spec.MaxSize = 0;
121            spec.MinTrack = 3;
122            spec.NotIsBin = 1;
123            cell = omFindCell(spec);
124            if (cell != NULL)
125            {   
126              omDebugAddrSize(cell->addr, GET_SIZE(cell->spec) + SIZEOF_OM_ALIGNMENT);
127            } else printf("cell not found\n");
128          }
129          else printf("cell not found\n");
130          break;
131        }
132
133        case omError_FreedAddr: 
134        {
135          spec.MinTrack = 5;
136          spec.NotIsBin = 1;
137          cell = omFindCell(spec);
138          if (cell != NULL)
139          {
140            omFree(cell->addr);
141            omFree(cell->addr);
142            alloc = 1;
143            cell->addr=NULL;
144          }
145          else printf("cell not found\n");
146          break;
147        }
148
149        case omError_FreedAddrOrMemoryCorrupted: 
150        {
151          spec.MaxSize = OM_MAX_BLOCK_SIZE;
152          spec.NoTrack = 1;
153          cell = omFindCell(spec);
154          if (cell != NULL)
155          {
156            omBinPage page = omGetBinPageOfAddr(cell->addr);
157            omBinPageRegion region = page->region;
158            page->region = NULL;
159            om_Opts.MinCheck = 1;
160            omDebugAddr(cell->addr);
161            om_Opts.MinCheck = 5;
162            page->region = region;
163          }
164          else printf("cell not found\n");
165          break;
166        }
167
168        case omError_WrongBin: 
169        {
170          spec.MaxSize = 32;
171          spec.NoTrack = 1;
172          cell = omFindCell(spec);
173          if (cell != NULL)
174          {
175            omDebugAddrBin(cell->addr, &om_StaticBin[OM_MAX_BIN_INDEX]);
176          }
177          else printf("cell not found\n");
178          break;
179        }
180
181        case omError_UnknownBin: 
182        {
183          spec.MaxSize = OM_MAX_BLOCK_SIZE;
184          cell = omFindCell(spec);
185          if (cell != NULL)
186          {
187            omDebugAddrBin(cell->addr, (void*) omGetTopBinOfAddr(cell->addr) + SIZEOF_VOIDP);
188          }
189          else printf("cell not found\n");
190          break;
191        }
192
193        case omError_UnalignedAddr: 
194        {
195          cell = omFindCell(spec);
196          if (cell != NULL)
197          {
198            omDebugAddr(cell->addr + 1);
199          }
200          else printf("cell not found\n");
201          break;
202        }
203
204        case omError_NullSizeAlloc: 
205        {
206          void* addr = omAlloc(0);
207          addr = omRealloc(addr, 0);
208          omFree(addr);
209          break;
210        }
211
212        case omError_ListCycleError: 
213        {
214          void* last = omListLast(om_SpecBin);
215          if (last != NULL)
216          {
217            *((void**)last) = om_SpecBin;
218            omCheckList(om_SpecBin, 5, omError_NoError, OM_FLR);
219            *((void**)last) = NULL;
220          } else printf("last == NULL\n");
221          break;
222        }
223
224        case omError_SortedListError: 
225        {
226          if (om_SpecBin != NULL && om_SpecBin->next != NULL)
227          {
228            int max_blocks = om_SpecBin->max_blocks;
229            om_SpecBin->max_blocks = om_SpecBin->next->max_blocks + 1;
230            omCheckSortedList(om_SpecBin, max_blocks, 5, omError_NoError, OM_FLR);
231            om_SpecBin->max_blocks = max_blocks;
232          } else printf("om_SpecBin->next == NULL\n");
233          break;
234        }
235
236        case omError_KeptAddrListCorrupted: 
237        {
238          if (om_KeptAddr != NULL)
239          {
240            void* last = omListLast(om_KeptAddr);
241            *((void**)last) = om_KeptAddr;
242            omDebugMemory();
243            *((void**)last) = NULL;
244          }
245          else printf("om_KeptAddr == NULL\n");
246          break;
247        }
248
249        case omError_FreePattern: 
250        {
251          if (om_Opts.Keep > 0)
252          {
253            spec.MinTrack=3;
254            spec.NotIsBin = 1;
255            cell = omFindCell(spec);
256            if (cell != NULL)
257            {
258              void* value;
259              omFree(cell->addr);
260              value = *((void**) cell->addr);
261              *((void**) cell->addr) = value -1;
262              omDebugMemory();
263              *((void**) cell->addr) = value;
264              alloc = 1;
265              cell->addr = NULL;
266            }
267            else printf("cell not found\n");
268          }
269          else printf("om_Opts.Keep == 0");
270          break;
271        }
272
273        case omError_BackPattern: 
274        {
275          spec.MinTrack = 3;
276          spec.NotIsBin = 1;
277          cell = omFindCell(spec);
278          if (cell != NULL)
279          {
280            void* addr = cell->addr + omSizeOfAddr(cell->addr);
281            void* value = *((void**) addr);
282            *((void**) addr) = value -1;
283            omDebugAddr(cell->addr);
284            *((void**) addr) = value;
285          }
286          else printf("cell not found\n");
287          break;
288        }
289
290        case omError_FrontPattern: 
291        {
292          spec.MinTrack=3;
293          cell = omFindCell(spec);
294          if (cell != NULL)
295          {
296            void* addr = cell->addr - SIZEOF_VOIDP;
297            void* value = *((void**) addr);
298            *((void**) addr) = value -1;
299            omDebugAddr(cell->addr);
300            *((void**) addr) = value; 
301          }
302          else printf("cell not found\n");
303          break;
304        }
305
306        case omError_NotString:
307        {
308          spec.MaxSize = OM_MAX_BLOCK_SIZE;
309          cell = omFindCell(spec);
310          if (cell != NULL)
311          {
312            char* addr = (char*) cell->addr;
313            char* s;
314            memset(cell->addr, 1, omSizeOfAddr(cell->addr));
315            omDebugAddr(cell->addr);
316            s = omStrDup(addr);
317            omFree(s);
318            InitCellAddrContent(cell);
319          }
320          else printf("cell not found\n");
321          break;
322        }
323        default:
324          printf("No Error test implemented\n");
325    }
326
327    if (om_ErrorStatus != error)
328    {
329      printf("---missed %s\n", omError2Serror(error));
330      missed++;
331    }
332    else
333    {
334      printf("+++ok  %s\n", omError2Serror(error));
335    }
336
337    om_ErrorStatus = omError_NoError;
338    if (cell != NULL)
339    {
340      if (alloc) TestAlloc(cell, cell->spec);
341      omtTestDebug(cell);
342    }
343    else
344    {
345      omDebugMemory();
346    }
347    if (om_ErrorStatus != omError_NoError)
348    {
349      printf("???panik: memory corrupted\n\n");
350      return -1;
351    }
352    printf("\n");
353  }
354  printf("omtTestErrors: Summary: missed = %d\n\n", missed);
355  om_Opts.MinCheck = level;
356  return missed;
357#else
358  return 0;
359#endif 
360}
361
362 
Note: See TracBrowser for help on using the repository browser.