Rename newtestsuite to testsuite
[dyninst.git] / testsuite / src / ResumeLog.C
1 /*
2  * Copyright (c) 1996-2008 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 #include <stdio.h>
43 #include <assert.h>
44 #include "test_results.h"
45 #include "test_info_new.h"
46 #include "test_lib.h"
47 #include "ResumeLog.h"
48 #include <assert.h>
49
50 #include <assert.h>
51 #include <stdlib.h>
52 #include <string.h>
53
54 static bool enableLog = false;
55 static const char *resumelog_name = "resumelog";
56
57 #define RESULT_REPORTED -1
58 #define RESUME_POINT -2
59 #define RESULT_CRASHED -3
60
61 struct resumeLogEntry {
62    resumeLogEntry(int gn, int tn, int rs, int res=0, bool use_res=false) :
63       groupnum(gn),
64       testnum(tn),
65       runstate(rs),
66       result(res),
67       use_result(use_res)
68    {}
69    int groupnum;
70    int testnum;
71    int runstate;
72    int result;
73    bool use_result;
74 };
75
76 void enableResumeLog()
77 {
78    enableLog = true;
79 }
80
81 bool isLogging()
82 {
83    return enableLog;
84 }
85
86 void setLoggingFilename(char *f)
87 {
88    resumelog_name = f;
89 }
90
91 void rebuild_resumelog(const std::vector<resumeLogEntry> &entries)
92 {
93    if (!enableLog)
94       return;
95
96    FILE *f = fopen(resumelog_name, "a");
97    
98    for (unsigned i=0; i<entries.size(); i++)
99    {
100       fprintf(f, "%d,%d,%d\n", entries[i].groupnum, entries[i].testnum, 
101               entries[i].runstate);
102       if (entries[i].use_result)
103          fprintf(f, "%d\n", entries[i].result);
104    }
105
106    fclose(f);
107 }
108
109 static void log_line(int groupnum, int testnum, int runstate, bool append)
110 {
111    if (!enableLog)
112       return;
113
114    FILE *f = fopen(resumelog_name, append ? "a" : "w");
115    if (!f) {
116       getOutput()->log(STDERR, "Failed to update the resume log");
117       return;
118    }
119    fprintf(f, "%d,%d,%d\n", groupnum, testnum, runstate);
120    fclose(f);
121 }
122
123 void log_teststart(int groupnum, int testnum, test_runstate_t runstate)
124 {
125    log_line(groupnum, testnum, (int) runstate, true);
126 }
127
128 void log_testresult(test_results_t result)
129 {
130    if (!enableLog)
131       return;
132
133    FILE *f = fopen(resumelog_name, "a");
134    if (!f) {
135       getOutput()->log(STDERR, "Failed to update the resume log");
136       return;
137    }
138    fprintf(f, "%d\n", result);
139    fclose(f);
140 }
141
142 void log_testreported(int groupnum, int testnum)
143 {
144    log_line(groupnum, testnum, RESULT_REPORTED, true);
145 }
146
147 static std::vector<resumeLogEntry> recreate_entries;
148
149 void log_resumepoint(int groupnum, int testnum)
150 {
151    log_line(groupnum, testnum, RESUME_POINT, false);
152    rebuild_resumelog(recreate_entries);
153 }
154
155 void log_clear()
156 {
157    if (!enableLog)
158       return;
159    FILE *f = fopen(resumelog_name, "w");
160    if (f)
161       fclose(f);
162 }
163
164 void parse_resumelog(std::vector<RunGroup *> &groups)
165 {
166    if (!enableLog)
167       return;
168
169
170    FILE *f = fopen(resumelog_name, "r");
171    if (!f) {
172       return;
173    }
174
175    int groupnum, testnum, runstate_int;
176    test_runstate_t runstate;
177    test_results_t result;
178    
179    for (;;)
180    {
181       int res = fscanf(f, "%d,%d,%d\n", &groupnum, &testnum, &runstate_int);
182       if (res != 3)
183          break;
184       
185       assert(groupnum >= 0 && groupnum < groups.size());
186       assert(groups[groupnum]);
187       assert(testnum >= 0);
188       assert(testnum < groups[groupnum]->tests.size());
189       if (runstate_int == RESULT_REPORTED)
190       {
191          groups[groupnum]->tests[testnum]->result_reported = true;
192          recreate_entries.push_back(resumeLogEntry(groupnum, testnum, RESULT_REPORTED));
193          continue;
194       }
195       if (runstate_int == RESUME_POINT)
196       {
197          for (unsigned i=0; i<groupnum; i++)
198          {
199             for (unsigned j=0; j<groups[i]->tests.size(); j++) {
200                groups[i]->tests[j]->disabled = true;
201             }
202             groups[i]->disabled = true;
203          }
204          for (unsigned j=0; j<testnum; j++) {
205             groups[groupnum]->tests[j]->disabled = true;
206          }
207          continue;
208       }
209       
210       assert(runstate_int >= 0 && runstate_int < NUM_RUNSTATES);
211       runstate = (test_runstate_t) runstate_int;
212
213       res = fscanf(f, "%d\n", &result);
214       if (res != 1) {
215          result = CRASHED;
216       }
217       switch (runstate) {
218          case test_setup_rs:
219          case test_init_rs:
220          case test_execute_rs:
221          case test_teardown_rs:
222             groups[groupnum]->tests[testnum]->results[runstate] = result;
223             break;
224          case group_setup_rs:
225          case group_teardown_rs:
226             for (unsigned i=0; i<groups[groupnum]->tests.size(); i++)
227             {
228                groups[groupnum]->tests[i]->results[runstate] = result;
229             }
230             break;
231          case program_setup_rs:
232          case program_teardown_rs:
233             for (unsigned i=0; i<groups.size(); i++)
234             {
235                if (groups[i]->mod != groups[groupnum]->mod)
236                   continue;
237                for (unsigned j=0; j<groups[i]->tests.size(); j++)
238                {
239                   groups[i]->tests[j]->results[runstate] = result;
240                }
241             }
242             break;
243       }
244       recreate_entries.push_back(resumeLogEntry(groupnum, testnum, 
245                                                 runstate_int, result, true));
246
247       if (res != 1)
248          break;
249    }
250
251    rebuild_resumelog(recreate_entries);
252 }
253
254 char *mutatee_resumelog_name = "mutatee_resumelog";
255
256 void parse_mutateelog(RunGroup *group)
257 {
258    FILE *f = fopen(mutatee_resumelog_name, "r");
259    assert(f);
260    char testname[256];
261    for (;;)
262    {
263       test_results_t result = UNKNOWN;
264       int res = fscanf(f, "%256s\n", testname);
265       if (res != 1) {
266          break;
267       }
268       
269       int passed;
270       res = fscanf(f, "%d\n", &passed);
271       if (res == EOF)
272          result = CRASHED;
273       else if (passed == 1)
274          result = PASSED;
275       else if (passed == 0)
276          result = FAILED;
277       else {
278          getOutput()->log(STDERR, "Error parsing mutatee log\n");
279          assert(0);
280       }
281       
282       bool found = false;
283       for (unsigned i=0; i<group->tests.size(); i++)
284       {
285          if (strcmp(group->tests[i]->name, testname) == 0)
286          {
287             group->tests[i]->results[group_teardown_rs] = result;
288             found = true;
289          }
290       }
291       assert(found);
292
293       if (result == CRASHED)
294          break;
295    }
296    fclose(f);
297 }
298
299 void clear_mutateelog()
300 {
301    FILE *f = fopen(mutatee_resumelog_name, "w");
302    if (!f) {
303       getOutput()->log(STDERR, "Unable to reset mutatee log\n");
304       exit(0);
305    }
306    fclose(f);
307 }