Implement stdin, stdout and stderr to Faustine.
[Faustine.git] / interpreter / lib / src / libsndfile-1.0.25 / tests / pipe_test.c
1 /*
2 ** Copyright (C) 2001-2011 Erik de Castro Lopo <erikd@mega-nerd.com>
3 **
4 ** This program is free software; you can redistribute it and/or modify
5 ** it under the terms of the GNU General Public License as published by
6 ** the Free Software Foundation; either version 2 of the License, or
7 ** (at your option) any later version.
8 **
9 ** This program is distributed in the hope that it will be useful,
10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 ** GNU General Public License for more details.
13 **
14 ** You should have received a copy of the GNU General Public License
15 ** along with this program; if not, write to the Free Software
16 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19 /*==========================================================================
20 ** This is a test program which tests reading from and writing to pipes.
21 */
22
23 #include "sfconfig.h"
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #if (OS_IS_WIN32 || HAVE_PIPE == 0 || HAVE_WAITPID == 0)
30
31 int
32 main (void)
33 {
34 puts (" pipe_test : this test doesn't work on this OS.") ;
35 return 0 ;
36 } /* main */
37
38 #else
39
40 #if HAVE_UNISTD_H
41 #include <unistd.h>
42 #endif
43
44 #include <errno.h>
45 #include <sys/types.h>
46 #include <sys/stat.h>
47 #include <sys/wait.h>
48
49 #include <sndfile.h>
50
51 #include "utils.h"
52
53 typedef struct
54 { int format ;
55 const char *ext ;
56 } FILETYPE ;
57
58 static int file_exists (const char *filename) ;
59 static void useek_pipe_rw_test (int filetype, const char *ext) ;
60 static void pipe_read_test (int filetype, const char *ext) ;
61 static void pipe_write_test (const char *ext) ;
62 static void pipe_test_others (FILETYPE*, FILETYPE*) ;
63
64 static FILETYPE read_write_types [] =
65 { { SF_FORMAT_RAW , "raw" },
66 { SF_FORMAT_AU , "au" },
67 /* Lite remove start */
68 { SF_FORMAT_PAF , "paf" },
69 { SF_FORMAT_IRCAM , "ircam" },
70 { SF_FORMAT_PVF , "pvf" },
71 /* Lite remove end */
72 { 0 , NULL }
73 } ;
74
75 static FILETYPE read_only_types [] =
76 { { SF_FORMAT_RAW , "raw" },
77 { SF_FORMAT_AU , "au" },
78 { SF_FORMAT_AIFF , "aiff" },
79 { SF_FORMAT_WAV , "wav" },
80 { SF_FORMAT_W64 , "w64" },
81 /* Lite remove start */
82 { SF_FORMAT_PAF , "paf" },
83 { SF_FORMAT_NIST , "nist" },
84 { SF_FORMAT_IRCAM , "ircam" },
85 { SF_FORMAT_MAT4 , "mat4" },
86 { SF_FORMAT_MAT5 , "mat5" },
87 { SF_FORMAT_SVX , "svx" },
88 { SF_FORMAT_PVF , "pvf" },
89 /* Lite remove end */
90 { 0 , NULL }
91 } ;
92
93 int
94 main (void)
95 { int k ;
96
97 if (file_exists ("libsndfile.spec.in"))
98 exit_if_true (chdir ("tests") != 0, "\n Error : chdir ('tests') failed.\n") ;
99
100 for (k = 0 ; read_only_types [k].format ; k++)
101 pipe_read_test (read_only_types [k].format, read_only_types [k].ext) ;
102
103 for (k = 0 ; read_write_types [k].format ; k++)
104 pipe_write_test (read_write_types [k].ext) ;
105
106 for (k = 0 ; read_write_types [k].format ; k++)
107 useek_pipe_rw_test (read_write_types [k].format, read_write_types [k].ext) ;
108
109 if (0)
110 pipe_test_others (read_write_types, read_only_types) ;
111
112 return 0 ;
113 } /* main */
114
115 /*==============================================================================
116 */
117
118 static void
119 pipe_read_test (int filetype, const char *ext)
120 { static short data [PIPE_TEST_LEN] ;
121 static char buffer [256] ;
122 static char filename [256] ;
123
124 SNDFILE *outfile ;
125 SF_INFO sfinfo ;
126 int k, retval ;
127
128 snprintf (filename, sizeof (filename), "pipe_in.%s", ext) ;
129 print_test_name ("pipe_read_test", filename) ;
130
131 sfinfo.format = filetype | SF_FORMAT_PCM_16 ;
132 sfinfo.channels = 1 ;
133 sfinfo.samplerate = 44100 ;
134
135 for (k = 0 ; k < PIPE_TEST_LEN ; k++)
136 data [k] = PIPE_INDEX (k) ;
137
138 outfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
139 test_writef_short_or_die (outfile, 0, data, PIPE_TEST_LEN, __LINE__) ;
140 sf_close (outfile) ;
141
142 snprintf (buffer, sizeof (buffer), "cat %s | ./stdin_test %s ", filename, ext) ;
143 if ((retval = system (buffer)) != 0)
144 { retval = WEXITSTATUS (retval) ;
145 printf ("\n\n Line %d : pipe test returned error for file type \"%s\".\n\n", __LINE__, ext) ;
146 exit (retval) ;
147 } ;
148
149 unlink (filename) ;
150 puts ("ok") ;
151
152 return ;
153 } /* pipe_read_test */
154
155 static void
156 pipe_write_test (const char *ext)
157 { static char buffer [256] ;
158
159 int retval ;
160
161 print_test_name ("pipe_write_test", ext) ;
162
163 snprintf (buffer, sizeof (buffer), "./stdout_test %s | ./stdin_test %s ", ext, ext) ;
164 if ((retval = system (buffer)))
165 { retval = WEXITSTATUS (retval) ;
166 printf ("\n\n Line %d : pipe test returned error file type \"%s\".\n\n", __LINE__, ext) ;
167 exit (retval) ;
168 } ;
169
170 puts ("ok") ;
171
172 return ;
173 } /* pipe_write_test */
174
175 /*==============================================================================
176 */
177
178
179 static void
180 useek_pipe_rw_short (const char * ext, SF_INFO * psfinfo_write, SF_INFO * psfinfo_read)
181 { static short buffer [PIPE_TEST_LEN] ;
182 static short data [PIPE_TEST_LEN] ;
183 SNDFILE *outfile ;
184 SNDFILE *infile_piped ;
185
186 int k, status = 0 ;
187 int pipefd [2] ;
188 pid_t pida ;
189
190 for (k = 0 ; k < PIPE_TEST_LEN ; k++)
191 data [k] = PIPE_INDEX (k) ;
192
193 /*
194 ** Create the pipe.
195 */
196 exit_if_true (pipe (pipefd) != 0, "\n\n%s %d : pipe failed : %s\n", __func__, __LINE__, strerror (errno)) ;
197
198 /*
199 ** Attach the write end of the pipe to be written to.
200 */
201 if ((outfile = sf_open_fd (pipefd [1], SFM_WRITE, psfinfo_write, SF_TRUE)) == NULL)
202 { printf ("\n\n%s %d : unable to create unseekable pipe for write type \"%s\".\n", __func__, __LINE__, ext) ;
203 printf ("\t%s\n\n", sf_strerror (outfile)) ;
204 exit (1) ;
205 } ;
206
207 if (sf_error (outfile) != SF_ERR_NO_ERROR)
208 { printf ("\n\n%s %d : unable to open unseekable pipe for write type \"%s\".\n\n", __func__, __LINE__, ext) ;
209 exit (1) ;
210 } ;
211
212 /*
213 ** Attach the read end of the pipe to be read from.
214 */
215 if ((infile_piped = sf_open_fd (pipefd [0], SFM_READ, psfinfo_read, SF_TRUE)) == NULL)
216 { printf ("\n\n%s %d : unable to create unseekable pipe for read type. \"%s\".\n\n", __func__, __LINE__, ext) ;
217 exit (1) ;
218 } ;
219
220 if (sf_error (infile_piped) != SF_ERR_NO_ERROR)
221 { printf ("\n\n%s %d : unable to open unseekable pipe for read type \"%s\".\n\n", __func__, __LINE__, ext) ;
222 exit (1) ;
223 } ;
224
225 /* Fork a child process that will write directly into the pipe. */
226 if ((pida = fork ()) == 0) /* child process */
227 { test_writef_short_or_die (outfile, 0, data, PIPE_TEST_LEN, __LINE__) ;
228 exit (0) ;
229 } ;
230
231 /* In the parent process, read from the pipe and compare what is read
232 ** to what is written, if they match everything went as planned.
233 */
234 test_readf_short_or_die (infile_piped, 0, buffer, PIPE_TEST_LEN, __LINE__) ;
235 if (memcmp (buffer, data, sizeof (buffer)) != 0)
236 { printf ("\n\n%s %d : unseekable pipe test failed for file type \"%s\".\n\n", __func__, __LINE__, ext) ;
237 exit (1) ;
238 } ;
239
240 /* Wait for the child process to return. */
241 waitpid (pida, &status, 0) ;
242 status = WEXITSTATUS (status) ;
243 sf_close (outfile) ;
244 sf_close (infile_piped) ;
245
246 if (status != 0)
247 { printf ("\n\n%s %d : status of child process is %d for file type %s.\n\n", __func__, __LINE__, status, ext) ;
248 exit (1) ;
249 } ;
250
251 return ;
252 } /* useek_pipe_rw_short */
253
254
255 static void
256 useek_pipe_rw_float (const char * ext, SF_INFO * psfinfo_write, SF_INFO * psfinfo_read)
257 { static float buffer [PIPE_TEST_LEN] ;
258 static float data [PIPE_TEST_LEN] ;
259 SNDFILE *outfile ;
260 SNDFILE *infile_piped ;
261
262 int k, status = 0 ;
263 int pipefd [2] ;
264 pid_t pida ;
265
266 for (k = 0 ; k < PIPE_TEST_LEN ; k++)
267 data [k] = PIPE_INDEX (k) ;
268
269 /*
270 ** Create the pipe.
271 */
272 exit_if_true (pipe (pipefd) != 0, "\n\n%s %d : pipe failed : %s\n", __func__, __LINE__, strerror (errno)) ;
273
274 /*
275 ** Attach the write end of the pipe to be written to.
276 */
277 if ((outfile = sf_open_fd (pipefd [1], SFM_WRITE, psfinfo_write, SF_TRUE)) == NULL)
278 { printf ("\n\n%s %d : unable to create unseekable pipe for write type \"%s\".\n", __func__, __LINE__, ext) ;
279 printf ("\t%s\n\n", sf_strerror (outfile)) ;
280 exit (1) ;
281 } ;
282
283 if (sf_error (outfile) != SF_ERR_NO_ERROR)
284 { printf ("\n\n%s %d : unable to open unseekable pipe for write type \"%s\".\n\n", __func__, __LINE__, ext) ;
285 exit (1) ;
286 } ;
287
288 /*
289 ** Attach the read end of the pipe to be read from.
290 */
291 if ((infile_piped = sf_open_fd (pipefd [0], SFM_READ, psfinfo_read, SF_TRUE)) == NULL)
292 { printf ("\n\n%s %d : unable to create unseekable pipe for read type. \"%s\".\n\n", __func__, __LINE__, ext) ;
293 exit (1) ;
294 } ;
295
296 if (sf_error (infile_piped) != SF_ERR_NO_ERROR)
297 { printf ("\n\n%s %d : unable to open unseekable pipe for read type \"%s\".\n\n", __func__, __LINE__, ext) ;
298 exit (1) ;
299 } ;
300
301 /* Fork a child process that will write directly into the pipe. */
302 if ((pida = fork ()) == 0) /* child process */
303 { test_writef_float_or_die (outfile, 0, data, PIPE_TEST_LEN, __LINE__) ;
304 exit (0) ;
305 } ;
306
307 /* In the parent process, read from the pipe and compare what is read
308 ** to what is written, if they match everything went as planned.
309 */
310 test_readf_float_or_die (infile_piped, 0, buffer, PIPE_TEST_LEN, __LINE__) ;
311 if (memcmp (buffer, data, sizeof (buffer)) != 0)
312 { printf ("\n\n%s %d : unseekable pipe test failed for file type \"%s\".\n\n", __func__, __LINE__, ext) ;
313 exit (1) ;
314 } ;
315
316 /* Wait for the child process to return. */
317 waitpid (pida, &status, 0) ;
318 status = WEXITSTATUS (status) ;
319 sf_close (outfile) ;
320 sf_close (infile_piped) ;
321
322 if (status != 0)
323 { printf ("\n\n%s %d : status of child process is %d for file type %s.\n\n", __func__, __LINE__, status, ext) ;
324 exit (1) ;
325 } ;
326
327 return ;
328 } /* useek_pipe_rw_float */
329
330
331 static void
332 useek_pipe_rw_double (const char * ext, SF_INFO * psfinfo_write, SF_INFO * psfinfo_read)
333 { static double buffer [PIPE_TEST_LEN] ;
334 static double data [PIPE_TEST_LEN] ;
335 SNDFILE *outfile ;
336 SNDFILE *infile_piped ;
337
338 int k, status = 0 ;
339 int pipefd [2] ;
340 pid_t pida ;
341
342 for (k = 0 ; k < PIPE_TEST_LEN ; k++)
343 data [k] = PIPE_INDEX (k) ;
344
345 /*
346 ** Create the pipe.
347 */
348 exit_if_true (pipe (pipefd) != 0, "\n\n%s %d : pipe failed : %s\n", __func__, __LINE__, strerror (errno)) ;
349
350 /*
351 ** Attach the write end of the pipe to be written to.
352 */
353 if ((outfile = sf_open_fd (pipefd [1], SFM_WRITE, psfinfo_write, SF_TRUE)) == NULL)
354 { printf ("\n\n%s %d : unable to create unseekable pipe for write type \"%s\".\n", __func__, __LINE__, ext) ;
355 printf ("\t%s\n\n", sf_strerror (outfile)) ;
356 exit (1) ;
357 } ;
358
359 if (sf_error (outfile) != SF_ERR_NO_ERROR)
360 { printf ("\n\n%s %d : unable to open unseekable pipe for write type \"%s\".\n\n", __func__, __LINE__, ext) ;
361 exit (1) ;
362 } ;
363
364 /*
365 ** Attach the read end of the pipe to be read from.
366 */
367 if ((infile_piped = sf_open_fd (pipefd [0], SFM_READ, psfinfo_read, SF_TRUE)) == NULL)
368 { printf ("\n\n%s %d : unable to create unseekable pipe for read type. \"%s\".\n\n", __func__, __LINE__, ext) ;
369 exit (1) ;
370 } ;
371
372 if (sf_error (infile_piped) != SF_ERR_NO_ERROR)
373 { printf ("\n\n%s %d : unable to open unseekable pipe for read type \"%s\".\n\n", __func__, __LINE__, ext) ;
374 exit (1) ;
375 } ;
376
377 /* Fork a child process that will write directly into the pipe. */
378 if ((pida = fork ()) == 0) /* child process */
379 { test_writef_double_or_die (outfile, 0, data, PIPE_TEST_LEN, __LINE__) ;
380 exit (0) ;
381 } ;
382
383 /* In the parent process, read from the pipe and compare what is read
384 ** to what is written, if they match everything went as planned.
385 */
386 test_readf_double_or_die (infile_piped, 0, buffer, PIPE_TEST_LEN, __LINE__) ;
387 if (memcmp (buffer, data, sizeof (buffer)) != 0)
388 { printf ("\n\n%s %d : unseekable pipe test failed for file type \"%s\".\n\n", __func__, __LINE__, ext) ;
389 exit (1) ;
390 } ;
391
392 /* Wait for the child process to return. */
393 waitpid (pida, &status, 0) ;
394 status = WEXITSTATUS (status) ;
395 sf_close (outfile) ;
396 sf_close (infile_piped) ;
397
398 if (status != 0)
399 { printf ("\n\n%s %d : status of child process is %d for file type %s.\n\n", __func__, __LINE__, status, ext) ;
400 exit (1) ;
401 } ;
402
403 return ;
404 } /* useek_pipe_rw_double */
405
406
407
408
409 static void
410 useek_pipe_rw_test (int filetype, const char *ext)
411 { SF_INFO sfinfo_write ;
412 SF_INFO sfinfo_read ;
413
414 print_test_name ("useek_pipe_rw_test", ext) ;
415
416 /*
417 ** Setup the INFO structures for the filetype we will be
418 ** working with.
419 */
420 sfinfo_write.format = filetype | SF_FORMAT_PCM_16 ;
421 sfinfo_write.channels = 1 ;
422 sfinfo_write.samplerate = 44100 ;
423
424
425 sfinfo_read.format = 0 ;
426 if (filetype == SF_FORMAT_RAW)
427 { sfinfo_read.format = filetype | SF_FORMAT_PCM_16 ;
428 sfinfo_read.channels = 1 ;
429 sfinfo_read.samplerate = 44100 ;
430 } ;
431
432 useek_pipe_rw_short (ext, &sfinfo_write, &sfinfo_read) ;
433
434 sfinfo_read.format = sfinfo_write.format = filetype | SF_FORMAT_FLOAT ;
435 if (sf_format_check (&sfinfo_read) != 0)
436 useek_pipe_rw_float (ext, &sfinfo_write, &sfinfo_read) ;
437
438 sfinfo_read.format = sfinfo_write.format = filetype | SF_FORMAT_DOUBLE ;
439 if (sf_format_check (&sfinfo_read) != 0)
440 useek_pipe_rw_double (ext, &sfinfo_write, &sfinfo_read) ;
441
442 puts ("ok") ;
443 return ;
444 } /* useek_pipe_rw_test */
445
446
447
448 static void
449 pipe_test_others (FILETYPE* list1, FILETYPE* list2)
450 { SF_FORMAT_INFO info ;
451 int k, m, major_count, in_list ;
452
453 print_test_name ("pipe_test_others", "") ;
454
455 sf_command (NULL, SFC_GET_FORMAT_MAJOR_COUNT, &major_count, sizeof (int)) ;
456
457 for (k = 0 ; k < major_count ; k++)
458 { info.format = k ;
459
460 sf_command (NULL, SFC_GET_FORMAT_MAJOR, &info, sizeof (info)) ;
461
462 in_list = SF_FALSE ;
463 for (m = 0 ; list1 [m].format ; m++)
464 if (info.format == list1 [m].format)
465 in_list = SF_TRUE ;
466
467 for (m = 0 ; list2 [m].format ; m++)
468 if (info.format == list2 [m].format)
469 in_list = SF_TRUE ;
470
471 if (in_list)
472 continue ;
473
474 printf ("%s %x\n", info.name, info.format) ;
475
476 if (1)
477 { static short data [PIPE_TEST_LEN] ;
478 static char buffer [256] ;
479 static const char *filename = "pipe_in.dat" ;
480
481 SNDFILE *outfile ;
482 SF_INFO sfinfo ;
483 int retval ;
484
485 sfinfo.format = info.format | SF_FORMAT_PCM_16 ;
486 sfinfo.channels = 1 ;
487 sfinfo.samplerate = 44100 ;
488
489 outfile = test_open_file_or_die (filename, SFM_WRITE, &sfinfo, SF_TRUE, __LINE__) ;
490 test_writef_short_or_die (outfile, 0, data, PIPE_TEST_LEN, __LINE__) ;
491 sf_close (outfile) ;
492
493 snprintf (buffer, sizeof (buffer), "cat %s | ./stdin_test %s %d ", filename, info.extension, PIPE_TEST_LEN) ;
494 if ((retval = system (buffer)) == 0)
495 { retval = WEXITSTATUS (retval) ;
496 printf ("\n\n Line %d : pipe test should have returned error file type \"%s\" but didn't.\n\n", __LINE__, info.name) ;
497 exit (1) ;
498 } ;
499
500 unlink (filename) ;
501 } ;
502 } ;
503
504
505 puts ("ok") ;
506
507 return ;
508 } /* pipe_test_others */
509
510
511 /*==============================================================================
512 */
513
514 static int
515 file_exists (const char *filename)
516 { struct stat buf ;
517
518 if (stat (filename, &buf))
519 return 0 ;
520
521 return 1 ;
522 } /* file_exists */
523
524 #endif
525