1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
|
## IPC::Cmd test suite ###
BEGIN { chdir 't' if -d 't' };
use strict;
use lib qw[../lib];
use File::Spec ();
use Test::More 'no_plan';
my $Class = 'IPC::Cmd';
my @Funcs = qw[run can_run];
my @Meths = qw[can_use_ipc_run can_use_ipc_open3 can_capture_buffer];
my $IsWin32 = $^O eq 'MSWin32';
my $Verbose = @ARGV ? 1 : 0;
use_ok( $Class, $_ ) for @Funcs;
can_ok( $Class, $_ ) for @Funcs, @Meths;
can_ok( __PACKAGE__, $_ ) for @Funcs;
my $Have_IPC_Run = $Class->can_use_ipc_run;
my $Have_IPC_Open3 = $Class->can_use_ipc_open3;
$IPC::Cmd::VERBOSE = $IPC::Cmd::VERBOSE = $Verbose;
### run tests in various configurations, based on what modules we have
my @Prefs = (
[ $Have_IPC_Run, $Have_IPC_Open3 ],
[ 0, $Have_IPC_Open3 ],
[ 0, 0 ]
);
### can_run tests
{
ok( can_run('perl'), q[Found 'perl' in your path] );
ok( !can_run('10283lkjfdalskfjaf'), q[Not found non-existant binary] );
}
### run tests that print only to stdout
{ ### list of commands and regexes matching output ###
my $map = [
# command # output regex
[ "$^X -v", qr/larry\s+wall/i, ],
[ [$^X, '-v'], qr/larry\s+wall/i, ],
[ "$^X -eprint+42 | $^X -neprint", qr/42/, ],
[ [$^X,qw[-eprint+42 |], $^X, qw|-neprint|], qr/42/, ],
];
diag( "Running tests that print only to stdout" ) if $Verbose;
### for each configuarion
for my $pref ( @Prefs ) {
diag( "Running config: IPC::Run: $pref->[0] IPC::Open3: $pref->[1]" )
if $Verbose;
$IPC::Cmd::USE_IPC_RUN = $IPC::Cmd::USE_IPC_RUN = $pref->[0];
$IPC::Cmd::USE_IPC_OPEN3 = $IPC::Cmd::USE_IPC_OPEN3 = $pref->[1];
### for each command
for my $aref ( @$map ) {
my $cmd = $aref->[0];
my $regex = $aref->[1];
my $pp_cmd = ref $cmd ? "@$cmd" : "$cmd";
diag( "Running '$pp_cmd' as " . (ref $cmd ? "ARRAY" : "SCALAR") )
if $Verbose;
### in scalar mode
{ diag( "Running scalar mode" ) if $Verbose;
my $buffer;
my $ok = run( command => $cmd, buffer => \$buffer );
ok( $ok, "Ran command succesfully" );
SKIP: {
skip "No buffers available", 1
unless $Class->can_capture_buffer;
like( $buffer, $regex,
" Buffer filled properly" );
}
}
### in list mode
{ diag( "Running list mode" ) if $Verbose;
my @list = run( command => $cmd );
ok( $list[0], "Command ran successfully" );
ok( !$list[1], " No error code set" );
my $list_length = $Class->can_capture_buffer ? 5 : 2;
is( scalar(@list), $list_length,
" Output list has $list_length entries" );
SKIP: {
skip "No buffers available", 6
unless $Class->can_capture_buffer;
### the last 3 entries from the RV, are they array refs?
isa_ok( $list[$_], 'ARRAY' ) for 2..4;
like( "@{$list[2]}", $regex,
" Combined buffer holds output" );
like( "@{$list[3]}", qr/$regex/,
" Stdout buffer filled" );
is( scalar( @{$list[4]} ), 0,
" Stderr buffer empty" );
}
}
}
}
}
### run tests that print only to stderr
### XXX lots of duplication from stdout tests, only difference
### is buffer inspection
{ ### list of commands and regexes matching output ###
my $map = [
# command # output regex
[ "$^X -ewarn+42", qr/^42 /, ],
[ [$^X, '-ewarn+42'], qr/^42 /, ],
];
diag( "Running tests that print only to stderr" ) if $Verbose;
### for each configuarion
for my $pref ( @Prefs ) {
diag( "Running config: IPC::Run: $pref->[0] IPC::Open3: $pref->[1]" )
if $Verbose;
$IPC::Cmd::USE_IPC_RUN = $IPC::Cmd::USE_IPC_RUN = $pref->[0];
$IPC::Cmd::USE_IPC_OPEN3 = $IPC::Cmd::USE_IPC_OPEN3 = $pref->[1];
### for each command
for my $aref ( @$map ) {
my $cmd = $aref->[0];
my $regex = $aref->[1];
my $pp_cmd = ref $cmd ? "@$cmd" : "$cmd";
diag( "Running '$pp_cmd' as " . (ref $cmd ? "ARRAY" : "SCALAR") )
if $Verbose;
### in scalar mode
{ diag( "Running stderr command in scalar mode" ) if $Verbose;
my $buffer;
my $ok = run( command => $cmd, buffer => \$buffer );
ok( $ok, "Ran stderr command succesfully in scalar mode." );
SKIP: {
# No buffers are expected if neither IPC::Run nor IPC::Open3 is used.
skip "No buffers available", 1
unless $Class->can_capture_buffer;
like( $buffer, $regex,
" Buffer filled properly from stderr" );
}
}
### in list mode
{ diag( "Running stderr command in list mode" ) if $Verbose;
my @list = run( command => $cmd );
ok( $list[0], "Ran stderr command successfully in list mode." );
ok( !$list[1], " No error code set" );
my $list_length = $Class->can_capture_buffer ? 5 : 2;
is( scalar(@list), $list_length,
" Output list has $list_length entries" );
SKIP: {
# No buffers are expected if neither IPC::Run nor IPC::Open3 is used.
skip "No buffers available", 6
unless $Class->can_capture_buffer;
### the last 3 entries from the RV, are they array refs?
isa_ok( $list[$_], 'ARRAY' ) for 2..4;
like( "@{$list[2]}", $regex,
" Combined buffer holds output" );
is( scalar( @{$list[3]} ), 0,
" Stdout buffer empty" );
like( "@{$list[4]}", qr/$regex/,
" Stderr buffer filled" );
}
}
}
}
}
### test failures
{ ### for each configuarion
for my $pref ( @Prefs ) {
diag( "Running config: IPC::Run: $pref->[0] IPC::Open3: $pref->[1]" )
if $Verbose;
$IPC::Cmd::USE_IPC_RUN = $IPC::Cmd::USE_IPC_RUN = $pref->[0];
$IPC::Cmd::USE_IPC_OPEN3 = $IPC::Cmd::USE_IPC_OPEN3 = $pref->[1];
my $ok = run( command => "$^X -ledie" );
ok( !$ok, "Failure caught" );
}
}
__END__
### check if IPC::Run is already loaded, if so, IPC::Run tests
### from IPC::Run are known to fail on win32
my $Skip_IPC_Run = ($^O eq 'MSWin32' && exists $INC{'IPC/Run.pm'}) ? 1 : 0;
use_ok( 'IPC::Cmd' ) or diag "Cmd.pm not found. Dying", die;
IPC::Cmd->import( qw[can_run run] );
### silence it ###
$IPC::Cmd::VERBOSE = $IPC::Cmd::VERBOSE = $ARGV[0] ? 1 : 0;
{
ok( can_run('perl'), q[Found 'perl' in your path] );
ok( !can_run('10283lkjfdalskfjaf'), q[Not found non-existant binary] );
}
{ ### list of commands and regexes matching output ###
my $map = [
["$^X -v", qr/larry\s+wall/i, ],
[[$^X, '-v'], qr/larry\s+wall/i, ],
["$^X -eprint1 | $^X -neprint", qr/1/, ],
[[$^X,qw[-eprint1 |], $^X, qw|-neprint|], qr/1/, ],
];
my @prefs = ( [1,1], [0,1], [0,0] );
### if IPC::Run is already loaded,remove tests involving IPC::Run
### when on win32
shift @prefs if $Skip_IPC_Run;
for my $pref ( @prefs ) {
$IPC::Cmd::USE_IPC_RUN = $IPC::Cmd::USE_IPC_RUN = $pref->[0];
$IPC::Cmd::USE_IPC_OPEN3 = $IPC::Cmd::USE_IPC_OPEN3 = $pref->[1];
for my $aref ( @$map ) {
my $cmd = $aref->[0];
my $regex = $aref->[1];
my $Can_Buffer;
my $captured;
my $ok = run( command => $cmd,
buffer => \$captured,
);
ok($ok, q[Successful run of command] );
SKIP: {
skip "No buffers returned", 1 unless $captured;
like( $captured, $regex, q[ Buffer filled] );
### if we get here, we have buffers ###
$Can_Buffer++;
}
my @list = run( command => $cmd );
ok( $list[0], "Command ran successfully" );
ok( !$list[1], " No error code set" );
SKIP: {
skip "No buffers, cannot do buffer tests", 3
unless $Can_Buffer;
ok( (grep /$regex/, @{$list[2]}),
" Out buffer filled" );
SKIP: {
skip "IPC::Run bug prevents separated " .
"stdout/stderr buffers", 2 if $pref->[0];
ok( (grep /$regex/, @{$list[3]}),
" Stdout buffer filled" );
ok( @{$list[4]} == 0,
" Stderr buffer empty" );
}
}
}
}
}
|
