Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
6cbcea47a3aa5e336c1731d5d9a372cfa03dd6fb
[simgrid.git] / tools / tesh / tesh.c
1 /* $Id$ */
2
3 /* TESH (Test Shell) -- mini shell specialized in running test units        */
4
5 /* Copyright (c) 2007 Martin Quinson.                                       */
6 /* All rights reserved.                                                     */
7
8 /* This program is free software; you can redistribute it and/or modify it
9  * under the terms of the license (GNU LGPL) which comes with this package. */
10
11 /* specific to Borland Compiler */
12 #ifdef __BORLANDDC__
13 #pragma hdrstop
14 #endif
15
16 #include "xbt/sysdep.h"
17 #include "xbt/function_types.h"
18 #include "xbt/log.h"
19 #include "portable.h"
20
21 #include <sys/types.h>
22 #include <sys/wait.h>
23
24 /**
25  ** Buffer code
26  **/
27 typedef struct {
28   char *data;
29   int used,size;
30 } buff_t;
31
32 static void buff_empty(buff_t *b) {
33   b->used=0;
34   b->data[0]='\n';
35   b->data[1]='\0';
36 }
37 static buff_t *buff_new(void) {
38   buff_t *res=malloc(sizeof(buff_t));
39   res->data=malloc(512);
40   res->size=512;
41   buff_empty(res);
42   return res;
43 }
44 static void buff_free(buff_t *b) {
45   if (b) {
46     if (b->data)
47       free(b->data);
48     free(b);
49   }
50 }
51 static void buff_append(buff_t *b, char *toadd) {
52   int addlen=strlen(toadd);
53   int needed_space=b->used+addlen+1;
54
55   if (needed_space > b->size) {
56     b->data = realloc(b->data, needed_space);
57     b->size = needed_space;
58   }
59   strcpy(b->data+b->used, toadd);
60   b->used += addlen;  
61 }
62 static void buff_chomp(buff_t *b) {
63   while (b->data[b->used] == '\n') {
64     b->data[b->used] = '\0';
65     if (b->used)
66       b->used--;
67   }
68 }
69 /**
70  ** Options
71  **/
72 int timeout_value = 5; /* child timeout value */
73 int expected_signal=0; /* !=0 if the following command should raise a signal */
74 int expected_return=0; /* the exepeted return code of following command */
75 int verbose=0; /* wheather we should wine on problems */
76
77 /**
78  ** Dealing with timeouts
79  **/
80 int timeouted;
81 static void timeout_handler(int sig) {
82   timeouted = 1;
83 }
84 /**
85  ** Dealing with timeouts
86  **/
87 int brokenpipe;
88 static void pipe_handler(int sig) {
89   brokenpipe = 1;
90 }
91
92 /**
93  ** Launching a child
94  **/
95 buff_t *input;
96 buff_t *output_wanted;
97 buff_t *output_got;
98
99 static void check_output() {
100   if (output_wanted->used==0 
101       && output_got->used==0)
102     return;
103   buff_chomp(output_got);
104   buff_chomp(output_wanted);
105
106   if (   output_got->used != output_wanted->used
107       || strcmp(output_got->data, output_wanted->data)) {
108     fprintf(stderr,"Output don't match expectations\n");
109     fprintf(stderr,">>>>> Expected %d chars:\n%s\n<<<<< Expected\n",
110             output_wanted->used,output_wanted->data);
111     fprintf(stderr,">>>>> Got %d chars:\n%s\n<<<<< Got\n",
112             output_got->used,output_got->data);
113     exit(2);
114   }
115   buff_empty(output_wanted);
116   buff_empty(output_got);
117   
118 }
119
120 static void exec_cmd(char *cmd) {
121   int child_stdin[2];
122   int child_stdout[2];
123
124   if (pipe(child_stdin) || pipe(child_stdout)) {
125     perror("Cannot open the pipes");
126     exit(4);
127   }
128
129   int pid=fork();
130   if (pid<0) {
131     perror("Cannot fork the command");
132     exit(4);
133   }
134
135   if (pid) { /* father */
136     char buffout[4096];
137     int posw,posr;
138     int status;
139     close(child_stdin[0]);
140     fcntl(child_stdin[1], F_SETFL, O_NONBLOCK);
141     close(child_stdout[1]);
142     fcntl(child_stdout[0], F_SETFL, O_NONBLOCK);
143
144     brokenpipe = 0;
145     for (posw=0; posw<input->used && !brokenpipe; ) {
146       int got;
147       //      fprintf(stderr,"Still %d chars to write\n",input->used-posw);
148       got=write(child_stdin[1],input->data+posw,input->used-posw);
149       if (got>0)
150         posw+=got;
151       if (got<0 && errno!=EINTR && errno!=EAGAIN && errno!=EPIPE) {
152         perror("Error while writing input to child");
153         exit(4);
154       }
155       //      fprintf(stderr,"written %d chars so far\n",posw);
156
157       posr=read(child_stdout[0],&buffout,4096);
158       //      fprintf(stderr,"got %d chars\n",posr);
159       if (posr<0 && errno!=EINTR && errno!=EAGAIN) {
160         perror("Error while reading output of child");
161         exit(4);
162       }
163       if (posr>0) {
164         buffout[posr]='\0';      
165         buff_append(output_got,buffout);
166       }
167        
168       if (got <= 0 && posr <= 0)
169          usleep(100);
170     }
171     input->data[0]='\0';
172     input->used=0;
173     close(child_stdin[1]);
174
175     timeouted = 0;
176     alarm(timeout_value);
177     do {
178       posr=read(child_stdout[0],&buffout,4096);
179       if (posr<0 && errno!=EINTR && errno!=EAGAIN) {
180         perror("Error while reading output of child");
181         exit(4);
182       }
183       if (posr>0) {
184         buffout[posr]='\0';
185         buff_append(output_got,buffout);
186       } else {
187         usleep(100);
188       }
189     } while (!timeouted && posr!=0);
190
191     /* Check for broken pipe */
192     if (brokenpipe && verbose) {
193       fprintf(stderr,"Warning: Child did not consume all its input (I got broken pipe)\n");
194     }
195
196     /* Check for timeouts */
197     if (timeouted) {
198       fprintf(stderr,"Child timeouted (waited %d sec)\n",timeout_value);
199       exit(3);
200     }
201     alarm(0);
202       
203
204     /* Wait for child, and check why it terminated */
205     wait(&status);
206
207     if (WIFSIGNALED(status) && WTERMSIG(status) != expected_signal) {
208       fprintf(stderr,"Child got signal %d instead of signal %d\n",
209               WTERMSIG(status), expected_signal);
210       exit(WTERMSIG(status)+4);
211     }
212     if (!WIFSIGNALED(status) && expected_signal != 0) {
213       fprintf(stderr,"Child didn't got expected signal %d\n",
214               expected_signal);
215       exit(5);
216     }
217
218     if (WIFEXITED(status) && WEXITSTATUS(status) != expected_return ) {
219       if (expected_return) 
220         fprintf(stderr,"Child returned code %d instead of %d\n",
221                 WEXITSTATUS(status), expected_return);
222       else
223         fprintf(stderr,"Child returned code %d\n", WEXITSTATUS(status));
224       exit(40+WEXITSTATUS(status));
225     }
226     expected_return = expected_signal = 0;
227
228   } else { /* child */
229
230     close(child_stdin[1]);
231     close(child_stdout[0]);
232     dup2(child_stdin[0],0);
233     close(child_stdin[0]);
234     dup2(child_stdout[1],1);
235     dup2(child_stdout[1],2);
236     close(child_stdout[1]);
237
238     execlp ("/bin/sh", "sh", "-c", cmd, NULL);
239   }
240 }
241
242 static void run_cmd(char *cmd) {
243   if (cmd[0] == 'c' && cmd[1] == 'd' && cmd[2] == ' ') {
244     int pos = 2;
245     /* Search end */
246     pos = strlen(cmd)-1;
247     while (cmd[pos] == '\n' || cmd[pos] == ' ' || cmd[pos] == '\t')
248       cmd[pos--] = '\0';
249     /* search begining */
250     pos = 2;
251     while (cmd[pos++] == ' ');
252     pos--;
253     //    fprintf(stderr,"Saw cd '%s'\n",cmd+pos);
254     if (chdir(cmd+pos)) {
255       perror("Chdir failed");
256       exit(4);
257     }
258     
259   } else {
260     exec_cmd(cmd);
261   }
262 }
263
264 static void handle_line(int nl, char *line) {
265   
266   // printf("%d: %s",nl,line);  fflush(stdout);
267   switch (line[0]) {
268   case '#': break;
269   case '$': 
270     check_output(); /* Check that last command ran well */
271      
272     printf("[%d] %s",nl,line);
273     fflush(stdout);
274     run_cmd(line+2);
275     break;
276     
277   case '<':
278     buff_append(input,line+2);
279     break;
280
281   case '>':
282     buff_append(output_wanted,line+2);
283     break;
284
285   case '!':
286     if (!strncmp(line+2,"set timeout ",strlen("set timeout "))) {
287       timeout_value=atoi(line+2+strlen("set timeout"));
288       printf("[%d] (new timeout value: %d)\n",
289              nl,timeout_value);
290
291     } else if (!strncmp(line+2,"expect signal ",strlen("expect signal "))) {
292       expected_signal = atoi(line+2+strlen("expect signal "));
293       printf("[%d] (next command must raise signal %d)\n", 
294              nl, expected_signal);
295
296     } else if (!strncmp(line+2,"expect return ",strlen("expect return "))) {
297       expected_return = atoi(line+2+strlen("expect return "));
298       printf("[%d] (next command must return code %d)\n",
299              nl, expected_return);
300        
301     } else if (!strncmp(line+2,"verbose on",strlen("verbose on"))) {
302       verbose = 1;
303       printf("[%d] (increase verbosity)\n", nl);
304        
305     } else if (!strncmp(line+2,"verbose off",strlen("verbose off"))) {
306       verbose = 1;
307       printf("[%d] (decrease verbosity)\n", nl);
308
309     } else {
310       fprintf(stderr,"%d: Malformed metacommand: %s",nl,line);
311       exit(1);
312     }
313     break;
314
315   case 'p':
316     printf("[%d] %s",nl,line+2);
317     break;
318
319   default:
320     fprintf(stderr,"Syntax error line %d: %s",nl, line);
321     exit(1);
322     break;
323   }
324 }
325
326 static int handle_suite(FILE* IN) {
327   int len;
328   char * line = NULL;
329   int line_num=0;
330
331   buff_t *buff=buff_new();
332   int buffbegin = 0;   
333
334   while (getline(&line,(size_t*) &len, IN) != -1) {
335     line_num++;
336
337     /* Count the line length while checking wheather it's blank */
338     int blankline=1;
339     int linelen = 0;    
340     while (line[linelen] != '\0') {
341       if (line[linelen] != ' ' && line[linelen] != '\t' && line[linelen]!='\n')
342         blankline = 0;
343       linelen++;
344     }
345     
346     if (blankline)
347       continue;
348
349     /* Deal with \ at the end of the line, and call handle_line on result */
350     int to_be_continued = 0;
351     if (linelen>1 && line[linelen-2]=='\\') {
352       if (linelen>2 && line[linelen-3] == '\\') {
353         /* Damn. Escaped \ */
354         line[linelen-2] = '\n';
355         line[linelen-1] = '\0';
356       } else {
357         to_be_continued = 1;
358         line[linelen-2] = '\0';
359         linelen -= 2;  
360         if (!buff->used)
361           buffbegin = line_num;
362       }
363     }
364
365     if (buff->used || to_be_continued) { 
366       buff_append(buff,line);
367
368       if (!to_be_continued) {
369         handle_line(buffbegin, buff->data);    
370         buff_empty(buff);
371       }
372         
373     } else {
374       handle_line(line_num,line);    
375     }
376   }
377   check_output(); /* Check that last command ran well */
378
379   /* Clear buffers */
380   if (line)
381     free(line);
382   buff_free(buff);
383   return 1;
384 }
385
386 int main(int argc,char *argv[]) {
387
388   /* Setup the signal handlers */
389   struct sigaction newact,oldact;
390   memset(&newact,0,sizeof(newact));
391   newact.sa_handler=timeout_handler;
392   sigaction(SIGALRM,&newact,&oldact);
393
394   newact.sa_handler=pipe_handler;
395   sigaction(SIGPIPE,&newact,&oldact);
396    
397   /* Setup the input/output buffers */
398   input=buff_new();
399   output_wanted=buff_new();
400   output_got=buff_new();
401
402   /* Find the description file */
403   FILE *IN;
404
405   if (argc == 1) {
406     printf("Test suite from stdin\n");fflush(stdout);
407     handle_suite(stdin);
408     fprintf(stderr,"Test suite from stdin OK\n");
409      
410   } else {
411     int i;
412      
413     for (i=1; i<argc; i++) {
414        printf("Test suite `%s'\n",argv[i]);fflush(stdout);
415        IN=fopen(argv[i], "r");
416        if (!IN) {
417           perror(bprintf("Impossible to open the suite file `%s'",argv[i]));
418           exit(1);
419        }
420        handle_suite(IN);
421        fclose(IN);
422        fprintf(stderr,"Test suite `%s' OK\n",argv[i]);
423     }
424   }
425    
426   buff_free(input);
427   buff_free(output_wanted);
428   buff_free(output_got);
429   return 0;  
430 }