Initial commit.
[qa-tools:testrunner-lite.git] / tests / unit / ut_manual_executor.c
1 /*
2  * This file is part of testrunner-lite
3  *
4  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
5  *
6  * Contact: Riku Halonen <riku.halonen@nokia.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public License
10  * version 2.1 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  *
22  */
23
24 /* ------------------------------------------------------------------------- */
25 /* INCLUDE FILES */
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <check.h>
29 #include <string.h>
30 #include <unistd.h>
31
32 #include "testrunnerlitetestscommon.h"
33 #include "testdefinitiondatatypes.h"
34 #include "manual_executor.h"
35
36 /* ------------------------------------------------------------------------- */
37 /* EXTERNAL DATA STRUCTURES */
38 /* None */
39
40 /* ------------------------------------------------------------------------- */
41 /* EXTERNAL GLOBAL VARIABLES */
42 /* None */
43
44 /* ------------------------------------------------------------------------- */
45 /* EXTERNAL FUNCTION PROTOTYPES */
46 /* None */
47
48 /* ------------------------------------------------------------------------- */
49 /* GLOBAL VARIABLES */
50 /* None */
51
52 /* ------------------------------------------------------------------------- */
53 /* CONSTANTS */
54 /* None */
55
56 /* ------------------------------------------------------------------------- */
57 /* MACROS */
58 /* None */
59
60 /* ------------------------------------------------------------------------- */
61 /* LOCAL GLOBAL VARIABLES */
62
63 /* ------------------------------------------------------------------------- */
64 /* LOCAL CONSTANTS AND MACROS */
65 /* None */
66
67 /* ------------------------------------------------------------------------- */
68 /* MODULE DATA STRUCTURES */
69 /* None */
70
71 /* ------------------------------------------------------------------------- */
72 /* LOCAL FUNCTION PROTOTYPES */
73 /* ------------------------------------------------------------------------- */
74 /* None */
75
76 /* ------------------------------------------------------------------------- */
77 /* FORWARD DECLARATIONS */
78 /* None */
79
80 /* ------------------------------------------------------------------------- */
81 /* ==================== LOCAL FUNCTIONS ==================================== */
82 /* ------------------------------------------------------------------------- */
83 START_TEST (test_execute_manual_step_passed)
84
85     td_case *t_case = NULL;
86     td_step *t_step = NULL;
87     FILE *fp;
88     int ret;
89     char cmd[1024];
90     char *stdout_tmp = "/tmp/testrunner-lite-manual-exec-stdout.log";
91     int pipefd[2];
92     
93     /* Forward stdout temporarily to a file. */
94     fp = freopen (stdout_tmp, "w", stdout);
95
96     /* redirect stdin from a pipe */
97     pipe(pipefd);
98     close(0);
99     dup(pipefd[0]);
100     
101     t_case = td_case_create();
102     t_case->gen.description = (xmlChar*)"This is manual test case.";
103
104     /* Execute print information. */
105     pre_manual (t_case);
106     
107     /* Back to terminal. */
108     freopen ("/dev/tty", "w", stdout);
109     sprintf (cmd, "grep \"This is manual test case.\" %s", stdout_tmp); 
110     ret = system (cmd);
111     fail_if (ret != 0, cmd);
112     
113     /* Forward stdout temporarily to a file. */
114     fp = freopen (stdout_tmp, "w", stdout);
115     
116     /* Execute manual step. */
117     t_step = td_step_create();
118     t_step->step = (xmlChar*)"This is manual test step.";
119     
120     /* Make test case pass. */
121     write(pipefd[1], "P\n", 2);
122     execute_manual (t_step);
123     
124     /* Back to terminal. */
125     freopen ("/dev/tty", "w", stdout);
126
127     sprintf (cmd, "grep \"This is manual test step.\" %s", stdout_tmp);
128     ret = system (cmd);
129     fail_if (ret != 0, cmd);
130     
131     t_case->case_res = CASE_PASS;
132     fp = freopen (stdout_tmp, "w", stdout);
133     
134     write(pipefd[1], "\n", 1);
135     post_manual (t_case);
136     
137     /* Back to terminal. */
138     freopen ("/dev/tty", "w", stdout);
139
140     sprintf (cmd, "grep \"PASSED.\" %s", stdout_tmp);
141     ret = system (cmd);
142     fail_if (ret != 0, cmd);
143
144     close(pipefd[0]);
145     close(pipefd[1]);
146     
147 END_TEST
148 /* ------------------------------------------------------------------------- */
149 START_TEST (test_execute_manual_step_failed)
150
151     td_case *t_case = NULL;
152     td_step *t_step = NULL;
153     FILE *fp;
154     int ret;
155     char cmd[1024];
156     char *stdout_tmp = "/tmp/testrunner-lite-manual-exec-stdout.log";
157     int pipefd[2];
158     
159     /* Forward stdout temporarily to a file. */
160     fp = freopen (stdout_tmp, "w", stdout);
161     
162     /* redirect stdin from a pipe */
163     pipe(pipefd);
164     close(0);
165     dup(pipefd[0]);
166
167     t_case = td_case_create();
168     t_case->gen.description = (xmlChar*)"This is manual test case.";
169
170     /* Execute print information. */
171     pre_manual (t_case);
172     
173     /* Back to terminal. */
174     freopen ("/dev/tty", "w", stdout);
175     sprintf (cmd, "grep \"This is manual test case.\" %s", stdout_tmp); 
176     ret = system (cmd);
177     fail_if (ret != 0, cmd);
178     
179     /* Forward stdout temporarily to a file. */
180     fp = freopen (stdout_tmp, "w", stdout);
181     
182     /* Execute manual step. */
183     t_step = td_step_create();
184     t_step->step = (xmlChar*)"This is manual test step.";
185     
186     /* Make test case fail. */
187     write(pipefd[1], "F\n", 2);
188     execute_manual (t_step);
189     
190     /* Back to terminal. */
191     freopen ("/dev/tty", "w", stdout);
192
193     sprintf (cmd, "grep \"This is manual test step.\" %s", stdout_tmp);
194     ret = system (cmd);
195     fail_if (ret != 0, cmd);
196     
197     t_case->case_res = CASE_FAIL;
198     fp = freopen (stdout_tmp, "w", stdout);
199     
200     write(pipefd[1], "\n", 1);
201     post_manual (t_case);
202     
203     /* Back to terminal. */
204     freopen ("/dev/tty", "w", stdout);
205
206     sprintf (cmd, "grep \"FAILED.\" %s", stdout_tmp);
207     ret = system (cmd);
208     fail_if (ret != 0, cmd);
209
210     close(pipefd[0]);
211     close(pipefd[1]);
212     
213 END_TEST
214
215 /* ------------------------------------------------------------------------- */
216 START_TEST (test_execute_manual_step_na)
217
218     td_case *t_case = NULL;
219     td_step *t_step = NULL;
220     FILE *fp;
221     int ret;
222     char cmd[1024];
223     char *stdout_tmp = "/tmp/testrunner-lite-manual-exec-stdout.log";
224     int pipefd[2];
225     
226     /* Forward stdout temporarily to a file. */
227     fp = freopen (stdout_tmp, "w", stdout);
228     
229     /* redirect stdin from a pipe */
230     pipe(pipefd);
231     close(0);
232     dup(pipefd[0]);
233
234     t_case = td_case_create();
235     t_case->gen.description = (xmlChar*)"This is manual test case.";
236
237     /* Execute print information. */
238     pre_manual (t_case);
239     
240     /* Back to terminal. */
241     freopen ("/dev/tty", "w", stdout);
242     sprintf (cmd, "grep \"This is manual test case.\" %s", stdout_tmp); 
243     ret = system (cmd);
244     fail_if (ret != 0, cmd);
245     
246     /* Forward stdout temporarily to a file. */
247     fp = freopen (stdout_tmp, "w", stdout);
248     
249     /* Execute manual step. */
250     t_step = td_step_create();
251     t_step->step = (xmlChar*)"This is manual test step.";
252     
253     /* Make test case fail. */
254     write(pipefd[1], "N\n", 2);
255     execute_manual (t_step);
256     
257     /* Back to terminal. */
258     freopen ("/dev/tty", "w", stdout);
259
260     sprintf (cmd, "grep \"This is manual test step.\" %s", stdout_tmp);
261     ret = system (cmd);
262     fail_if (ret != 0, cmd);
263     
264     t_case->case_res = CASE_NA;
265     fp = freopen (stdout_tmp, "w", stdout);
266     
267     write(pipefd[1], "\n", 1);
268     post_manual (t_case);
269     
270     /* Back to terminal. */
271     freopen ("/dev/tty", "w", stdout);
272
273     sprintf (cmd, "grep \"N/A.\" %s", stdout_tmp);
274     ret = system (cmd);
275     fail_if (ret != 0, cmd);
276
277     close(pipefd[0]);
278     close(pipefd[1]);
279     
280 END_TEST
281 /* ------------------------------------------------------------------------- */
282
283 START_TEST (test_execute_manual_set)
284      int ret;
285      FILE *f;
286
287      f = popen ("testrunner-lite -f /usr/share/testrunner-lite-tests/testdata/"
288                  "testrunner-tests-manual-set.xml -o /tmp/res.xml", "w");
289      fail_if (f == NULL, "popen() failed");
290      ret = fwrite ("P\nP\n\n", 1, 5, f);
291      fail_if (ret != 5, "fwrite() returned : %d", ret);
292      fclose (f);
293      
294      ret = system ("grep PASS /tmp/res.xml");
295      fail_if (ret, "/tmp/res.xml does not contain PASS");
296
297      ret = system ("grep FAIL /tmp/res.xml");
298      fail_unless (ret, "/tmp/res.xml contains FAIL");
299
300 END_TEST
301
302 /* ------------------------------------------------------------------------- */
303 /* ======================== FUNCTIONS ====================================== */
304 /* ------------------------------------------------------------------------- */
305 Suite *make_manualtestexecutor_suite (void)
306 {
307     /* Create suite. */
308     Suite *s = suite_create ("manual_executor");
309
310     /* Create test cases and add to suite. */
311     TCase *tc;
312
313     tc = tcase_create ("Test executing passed manual step.");
314     tcase_add_test (tc, test_execute_manual_step_passed);
315     suite_add_tcase (s, tc);
316
317     tc = tcase_create ("Test executing failing manual step.");
318     tcase_add_test (tc, test_execute_manual_step_failed);
319     suite_add_tcase (s, tc);
320
321     tc = tcase_create ("Test executing n/a manual step.");
322     tcase_add_test (tc, test_execute_manual_step_na);
323     suite_add_tcase (s, tc);
324
325
326     tc = tcase_create ("Test executing manual set.");
327     tcase_add_test (tc, test_execute_manual_set);
328     suite_add_tcase (s, tc);
329
330     return s;
331 }
332
333 /* ================= OTHER EXPORTED FUNCTIONS ============================== */
334 /* None */
335
336 /* ------------------------------------------------------------------------- */
337 /* End of file */