This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
make qr/(?{ __SUB__ })/ safe
[perl5.git] / t / op / smartkve.t
1 #!./perl
2
3 BEGIN {
4     chdir 't' if -d 't';
5     @INC = '../lib';
6     require './test.pl';
7 }
8 use strict;
9 use warnings;
10 no warnings 'deprecated';
11 use vars qw($data $array $values $hash $errpat);
12
13 plan 'no_plan';
14
15 sub j { join(":",@_) }
16
17 # NOTE
18 #
19 # Hash insertion is currently unstable, in that
20 # %hash= %otherhash will not necessarily result in
21 # the same internal ordering of the data in the hash.
22 # For instance when keys collide the copy may not
23 # match the inserted order. So we declare one hash
24 # and then make all our copies from that, which should
25 # mean all the copies have the same internal structure.
26 #
27 # And these days, even if all that weren't true, we now
28 # per-hash randomize keys/values. So, we cant expect two
29 # hashes with the same internal structure to return the
30 # same thing at all. All we *can* expect is that keys()
31 # and values() use the same ordering.
32 our %base_hash;
33
34 BEGIN { # in BEGIN for "use constant ..." later
35   # values match keys here so we can easily check that keys(%hash) == values(%hash)
36   %base_hash= (  pi => 'pi', e => 'e', i => 'i' );
37   $array = [ qw(pi e i) ];
38   $values = [ qw(pi e i) ];
39   $hash  = { %base_hash } ;
40   $data = {
41     hash => { %base_hash },
42     array => [ @$array ],
43   };
44 }
45
46 package Foo;
47 sub new {
48   my $self = {
49     hash => { %base_hash },
50     array => [@{$main::array}]
51   };
52   bless $self, shift;
53 }
54 sub hash { no overloading; $_[0]->{hash} };
55 sub array { no overloading; $_[0]->{array} };
56
57 package Foo::Overload::Array;
58 sub new { return bless [ qw/foo bar/ ], shift }
59 use overload '@{}' => sub { $main::array }, fallback => 1;
60
61 package Foo::Overload::Hash;
62 sub new { return bless { qw/foo bar/ }, shift }
63 use overload '%{}' => sub { $main::hash }, fallback => 1;
64
65 package Foo::Overload::Both;
66 sub new { return bless { qw/foo bar/ }, shift }
67 use overload  '%{}' => sub { $main::hash },
68               '@{}' => sub { $main::array }, fallback => 1;
69
70 package Foo::Overload::HashOnArray;
71 sub new { return bless [ qw/foo bar/ ], shift }
72 use overload '%{}' => sub { $main::hash }, fallback => 1;
73
74 package Foo::Overload::ArrayOnHash;
75 sub new { return bless { qw/foo bar/ }, shift }
76 use overload '@{}' => sub { $main::array }, fallback => 1;
77
78 package main;
79
80 use constant CONST_HASH => { %base_hash };
81 use constant CONST_ARRAY => [ @$array ];
82
83 my %a_hash = %base_hash;
84 my @an_array = @$array;
85 sub hash_sub { return \%a_hash; }
86 sub array_sub { return \@an_array; }
87
88 my $obj = Foo->new;
89
90 my ($empty, $h_expect, $a_expect, @tmp, @tmp2, $k, $v);
91
92 # Keys -- void
93
94 keys $hash;             pass('Void: keys $hash;');
95 keys $data->{hash};     pass('Void: keys $data->{hash};');
96 keys CONST_HASH;        pass('Void: keys CONST_HASH;');
97 keys CONST_HASH();      pass('Void: keys CONST_HASH();');
98 keys hash_sub();        pass('Void: keys hash_sub();');
99 keys hash_sub;          pass('Void: keys hash_sub;');
100 keys $obj->hash;        pass('Void: keys $obj->hash;');
101 keys $array;            pass('Void: keys $array;');
102 keys $data->{array};    pass('Void: keys $data->{array};');
103 keys CONST_ARRAY;       pass('Void: keys CONST_ARRAY;');
104 keys CONST_ARRAY();     pass('Void: keys CONST_ARRAY();');
105 keys array_sub;         pass('Void: keys array_sub;');
106 keys array_sub();       pass('Void: keys array_sub();');
107 keys $obj->array;       pass('Void: keys $obj->array;');
108
109 # Keys -- scalar
110
111 is(keys $hash           ,3, 'Scalar: keys $hash');
112 is(keys $data->{hash}   ,3, 'Scalar: keys $data->{hash}');
113 is(keys CONST_HASH      ,3, 'Scalar: keys CONST_HASH');
114 is(keys CONST_HASH()    ,3, 'Scalar: keys CONST_HASH()');
115 is(keys hash_sub        ,3, 'Scalar: keys hash_sub');
116 is(keys hash_sub()      ,3, 'Scalar: keys hash_sub()');
117 is(keys $obj->hash      ,3, 'Scalar: keys $obj->hash');
118 is(keys $array          ,3, 'Scalar: keys $array');
119 is(keys $data->{array}  ,3, 'Scalar: keys $data->{array}');
120 is(keys CONST_ARRAY     ,3, 'Scalar: keys CONST_ARRAY');
121 is(keys CONST_ARRAY()   ,3, 'Scalar: keys CONST_ARRAY()');
122 is(keys array_sub       ,3, 'Scalar: keys array_sub');
123 is(keys array_sub()     ,3, 'Scalar: keys array_sub()');
124 is(keys $obj->array     ,3, 'Scalar: keys $obj->array');
125
126 # Keys -- list
127
128 $h_expect = j(sort keys %base_hash);
129 $a_expect = j(keys @$array);
130
131 is(j(sort keys $hash)           ,$h_expect, 'List: sort keys $hash');
132 is(j(sort keys $data->{hash})   ,$h_expect, 'List: sort keys $data->{hash}');
133 is(j(sort keys CONST_HASH)      ,$h_expect, 'List: sort keys CONST_HASH');
134 is(j(sort keys CONST_HASH())    ,$h_expect, 'List: sort keys CONST_HASH()');
135 is(j(sort keys hash_sub)        ,$h_expect, 'List: sort keys hash_sub');
136 is(j(sort keys hash_sub())      ,$h_expect, 'List: sort keys hash_sub()');
137 is(j(sort keys $obj->hash)      ,$h_expect, 'List: sort keys $obj->hash');
138
139 is(j(keys $hash)                ,j(values $hash),           'List: keys $hash == values $hash');
140 is(j(keys $data->{hash})        ,j(values $data->{hash}),   'List: keys $data->{hash} == values $data->{hash}');
141 is(j(keys CONST_HASH)           ,j(values CONST_HASH),      'List: keys CONST_HASH == values CONST_HASH');
142 is(j(keys CONST_HASH())         ,j(values CONST_HASH()),    'List: keys CONST_HASH() == values CONST_HASH()');
143 is(j(keys hash_sub)             ,j(values hash_sub),        'List: keys hash_sub == values hash_sub');
144 is(j(keys hash_sub())           ,j(values hash_sub()),      'List: keys hash_sub() == values hash_sub()');
145 is(j(keys $obj->hash)           ,j(values $obj->hash),      'List: keys $obj->hash == values obj->hash');
146
147 is(j(keys $array)               ,$a_expect, 'List: keys $array');
148 is(j(keys $data->{array})       ,$a_expect, 'List: keys $data->{array}');
149 is(j(keys CONST_ARRAY)          ,$a_expect, 'List: keys CONST_ARRAY');
150 is(j(keys CONST_ARRAY())        ,$a_expect, 'List: keys CONST_ARRAY()');
151 is(j(keys array_sub)            ,$a_expect, 'List: keys array_sub');
152 is(j(keys array_sub())          ,$a_expect, 'List: keys array_sub()');
153 is(j(keys $obj->array)          ,$a_expect, 'List: keys $obj->array');
154
155 # Keys -- vivification
156 undef $empty;
157 eval { keys $empty->{hash} };
158 ok(defined $empty,
159   'Vivify: $empty (after keys $empty->{hash}) is HASHREF');
160 ok(!defined $empty->{hash}      ,   'Vivify: $empty->{hash} is undef');
161
162 # Keys -- lvalue
163 $_{foo} = "bar";
164 keys \%_ = 65;
165 is scalar %_, '1/128', 'keys $hashref as lvalue';
166 eval 'keys \@_ = 65';
167 like $@, qr/Can't modify keys on reference in scalar assignment/,
168   'keys $arrayref as lvalue dies';
169
170 # Keys -- errors
171 $errpat = qr/
172  (?-x:Type of argument to keys on reference must be unblessed hashref or)
173  (?-x: arrayref)
174 /x;
175
176 eval "keys undef";
177 ok($@ =~ $errpat,
178   'Errors: keys undef throws error'
179 );
180
181 undef $empty;
182 eval q"keys $empty";
183 ok($@ =~ $errpat,
184   'Errors: keys $undef throws error'
185 );
186
187 is($empty, undef, 'keys $undef does not vivify $undef');
188
189 eval "keys 3";
190 ok($@ =~ qr/Type of arg 1 to keys must be hash/,
191   'Errors: keys CONSTANT throws error'
192 );
193
194 eval "keys qr/foo/";
195 ok($@ =~ $errpat,
196   'Errors: keys qr/foo/ throws error'
197 );
198
199 eval "keys $hash qw/fo bar/";
200 ok($@ =~ qr/syntax error/,
201   'Errors: keys $hash, @stuff throws error'
202 ) or print "# Got: $@";
203
204 # Values -- void
205
206 values $hash;             pass('Void: values $hash;');
207 values $data->{hash};     pass('Void: values $data->{hash};');
208 values CONST_HASH;        pass('Void: values CONST_HASH;');
209 values CONST_HASH();      pass('Void: values CONST_HASH();');
210 values hash_sub();        pass('Void: values hash_sub();');
211 values hash_sub;          pass('Void: values hash_sub;');
212 values $obj->hash;        pass('Void: values $obj->hash;');
213 values $array;            pass('Void: values $array;');
214 values $data->{array};    pass('Void: values $data->{array};');
215 values CONST_ARRAY;       pass('Void: values CONST_ARRAY;');
216 values CONST_ARRAY();     pass('Void: values CONST_ARRAY();');
217 values array_sub;         pass('Void: values array_sub;');
218 values array_sub();       pass('Void: values array_sub();');
219 values $obj->array;       pass('Void: values $obj->array;');
220
221 # Values -- scalar
222
223 is(values $hash           ,3, 'Scalar: values $hash');
224 is(values $data->{hash}   ,3, 'Scalar: values $data->{hash}');
225 is(values CONST_HASH      ,3, 'Scalar: values CONST_HASH');
226 is(values CONST_HASH()    ,3, 'Scalar: values CONST_HASH()');
227 is(values hash_sub        ,3, 'Scalar: values hash_sub');
228 is(values hash_sub()      ,3, 'Scalar: values hash_sub()');
229 is(values $obj->hash      ,3, 'Scalar: values $obj->hash');
230 is(values $array          ,3, 'Scalar: values $array');
231 is(values $data->{array}  ,3, 'Scalar: values $data->{array}');
232 is(values CONST_ARRAY     ,3, 'Scalar: values CONST_ARRAY');
233 is(values CONST_ARRAY()   ,3, 'Scalar: values CONST_ARRAY()');
234 is(values array_sub       ,3, 'Scalar: values array_sub');
235 is(values array_sub()     ,3, 'Scalar: values array_sub()');
236 is(values $obj->array     ,3, 'Scalar: values $obj->array');
237
238 # Values -- list
239
240 $h_expect = j(sort values %base_hash);
241 $a_expect = j(values @$array);
242
243 is(j(sort values $hash)                ,$h_expect, 'List: sort values $hash');
244 is(j(sort values $data->{hash})        ,$h_expect, 'List: sort values $data->{hash}');
245 is(j(sort values CONST_HASH)           ,$h_expect, 'List: sort values CONST_HASH');
246 is(j(sort values CONST_HASH())         ,$h_expect, 'List: sort values CONST_HASH()');
247 is(j(sort values hash_sub)             ,$h_expect, 'List: sort values hash_sub');
248 is(j(sort values hash_sub())           ,$h_expect, 'List: sort values hash_sub()');
249 is(j(sort values $obj->hash)           ,$h_expect, 'List: sort values $obj->hash');
250
251 is(j(values $hash)                ,j(keys $hash),           'List: values $hash == keys $hash');
252 is(j(values $data->{hash})        ,j(keys $data->{hash}),   'List: values $data->{hash} == keys $data->{hash}');
253 is(j(values CONST_HASH)           ,j(keys CONST_HASH),      'List: values CONST_HASH == keys CONST_HASH');
254 is(j(values CONST_HASH())         ,j(keys CONST_HASH()),    'List: values CONST_HASH() == keys CONST_HASH()');
255 is(j(values hash_sub)             ,j(keys hash_sub),        'List: values hash_sub == keys hash_sub');
256 is(j(values hash_sub())           ,j(keys hash_sub()),      'List: values hash_sub() == keys hash_sub()');
257 is(j(values $obj->hash)           ,j(keys $obj->hash),      'List: values $obj->hash == keys $obj->hash');
258
259 is(j(values $array)               ,$a_expect, 'List: values $array');
260 is(j(values $data->{array})       ,$a_expect, 'List: values $data->{array}');
261 is(j(values CONST_ARRAY)          ,$a_expect, 'List: values CONST_ARRAY');
262 is(j(values CONST_ARRAY())        ,$a_expect, 'List: values CONST_ARRAY()');
263 is(j(values array_sub)            ,$a_expect, 'List: values array_sub');
264 is(j(values array_sub())          ,$a_expect, 'List: values array_sub()');
265 is(j(values $obj->array)          ,$a_expect, 'List: values $obj->array');
266
267 # Values -- vivification
268 undef $empty;
269 eval { values $empty->{hash} };
270 ok(defined $empty,
271   'Vivify: $empty (after values $empty->{hash}) is HASHREF');
272 ok(!defined $empty->{hash}      ,   'Vivify: $empty->{hash} is undef');
273
274 # Values -- errors
275 $errpat = qr/
276  (?-x:Type of argument to values on reference must be unblessed hashref or)
277  (?-x: arrayref)
278 /x;
279
280 eval "values undef";
281 ok($@ =~ $errpat,
282   'Errors: values undef throws error'
283 );
284
285 undef $empty;
286 eval q"values $empty";
287 ok($@ =~ $errpat,
288   'Errors: values $undef throws error'
289 );
290
291 is($empty, undef, 'values $undef does not vivify $undef');
292
293 eval "values 3";
294 ok($@ =~ qr/Type of arg 1 to values must be hash/,
295   'Errors: values CONSTANT throws error'
296 );
297
298 eval "values qr/foo/";
299 ok($@ =~ $errpat,
300   'Errors: values qr/foo/ throws error'
301 );
302
303 eval "values $hash qw/fo bar/";
304 ok($@ =~ qr/syntax error/,
305   'Errors: values $hash, @stuff throws error'
306 ) or print "# Got: $@";
307
308 # Each -- void
309
310 each $hash;             pass('Void: each $hash');
311 each $data->{hash};     pass('Void: each $data->{hash}');
312 each CONST_HASH;        pass('Void: each CONST_HASH');
313 each CONST_HASH();      pass('Void: each CONST_HASH()');
314 each hash_sub();        pass('Void: each hash_sub()');
315 each hash_sub;          pass('Void: each hash_sub');
316 each $obj->hash;        pass('Void: each $obj->hash');
317 each $array;            pass('Void: each $array');
318 each $data->{array};    pass('Void: each $data->{array}');
319 each CONST_ARRAY;       pass('Void: each CONST_ARRAY');
320 each CONST_ARRAY();     pass('Void: each CONST_ARRAY()');
321 each array_sub;         pass('Void: each array_sub');
322 each array_sub();       pass('Void: each array_sub()');
323 each $obj->array;       pass('Void: each $obj->array');
324
325 # Reset iterators
326
327 keys $hash;
328 keys $data->{hash};
329 keys CONST_HASH;
330 keys CONST_HASH();
331 keys hash_sub();
332 keys hash_sub;
333 keys $obj->hash;
334 keys $array;
335 keys $data->{array};
336 keys CONST_ARRAY;
337 keys CONST_ARRAY();
338 keys array_sub;
339 keys array_sub();
340 keys $obj->array;
341
342 # Each -- scalar
343
344 @tmp=(); while(defined( $k = each $hash)) {push @tmp,$k}; is(j(@tmp),j(keys $hash), 'Scalar: each $hash');
345 @tmp=(); while(defined( $k = each $data->{hash})){push @tmp,$k}; is(j(@tmp),j(keys $data->{hash}), 'Scalar: each $data->{hash}');
346 @tmp=(); while(defined( $k = each CONST_HASH)){push @tmp,$k}; is(j(@tmp),j(keys CONST_HASH), 'Scalar: each CONST_HASH');
347 @tmp=(); while(defined( $k = each CONST_HASH())){push @tmp,$k}; is(j(@tmp),j(keys CONST_HASH()), 'Scalar: each CONST_HASH()');
348 @tmp=(); while(defined( $k = each hash_sub())){push @tmp,$k}; is(j(@tmp),j(keys hash_sub()), 'Scalar: each hash_sub()');
349 @tmp=(); while(defined( $k = each hash_sub)){push @tmp,$k}; is(j(@tmp),j(keys hash_sub), 'Scalar: each hash_sub');
350 @tmp=(); while(defined( $k = each $obj->hash)){push @tmp,$k}; is(j(@tmp),j(keys $obj->hash), 'Scalar: each $obj->hash');
351 @tmp=(); while(defined( $k = each $array)){push @tmp,$k}; is(j(@tmp),j(keys $array), 'Scalar: each $array');
352 @tmp=(); while(defined( $k = each $data->{array})){push @tmp,$k}; is(j(@tmp),j(keys $data->{array}), 'Scalar: each $data->{array}');
353 @tmp=(); while(defined( $k = each CONST_ARRAY)){push @tmp,$k}; is(j(@tmp),j(keys CONST_ARRAY), 'Scalar: each CONST_ARRAY');
354 @tmp=(); while(defined( $k = each CONST_ARRAY())){push @tmp,$k}; is(j(@tmp),j(keys CONST_ARRAY()), 'Scalar: each CONST_ARRAY()');
355 @tmp=(); while(defined( $k = each array_sub)){push @tmp,$k}; is(j(@tmp),j(keys array_sub), 'Scalar: each array_sub');
356 @tmp=(); while(defined( $k = each array_sub())){push @tmp,$k}; is(j(@tmp),j(keys array_sub()), 'Scalar: each array_sub()');
357 @tmp=(); while(defined( $k = each $obj->array)){push @tmp,$k}; is(j(@tmp),j(keys $obj->array), 'Scalar: each $obj->array');
358
359 # Each -- list
360
361 @tmp=@tmp2=(); while(($k,$v) = each $hash) {push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys $hash, values $hash), 'List: each $hash');
362 @tmp=@tmp2=(); while(($k,$v) = each $data->{hash}){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys $data->{hash}, values $data->{hash}), 'List: each $data->{hash}');
363 @tmp=@tmp2=(); while(($k,$v) = each CONST_HASH){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys CONST_HASH, values CONST_HASH), 'List: each CONST_HASH');
364 @tmp=@tmp2=(); while(($k,$v) = each CONST_HASH()){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys CONST_HASH(), values CONST_HASH()), 'List: each CONST_HASH()');
365 @tmp=@tmp2=(); while(($k,$v) = each hash_sub()){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys hash_sub(), values hash_sub()), 'List: each hash_sub()');
366 @tmp=@tmp2=(); while(($k,$v) = each hash_sub){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys hash_sub, values hash_sub), 'List: each hash_sub');
367 @tmp=@tmp2=(); while(($k,$v) = each $obj->hash){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys $obj->hash, values $obj->hash), 'List: each $obj->hash');
368 @tmp=@tmp2=(); while(($k,$v) = each $array){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys $array, values $array), 'List: each $array');
369 @tmp=@tmp2=(); while(($k,$v) = each $data->{array}){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys $data->{array}, values $data->{array}), 'List: each $data->{array}');
370 @tmp=@tmp2=(); while(($k,$v) = each CONST_ARRAY){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys CONST_ARRAY, values CONST_ARRAY), 'List: each CONST_ARRAY');
371 @tmp=@tmp2=(); while(($k,$v) = each CONST_ARRAY()){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys CONST_ARRAY(), values CONST_ARRAY()), 'List: each CONST_ARRAY()');
372 @tmp=@tmp2=(); while(($k,$v) = each array_sub){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys array_sub, values array_sub), 'List: each array_sub');
373 @tmp=@tmp2=(); while(($k,$v) = each array_sub()){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys array_sub(), values array_sub()), 'List: each array_sub()');
374 @tmp=@tmp2=(); while(($k,$v) = each $obj->array){push @tmp,$k; push @tmp2,$v}; is(j(@tmp,@tmp2),j(keys $obj->array, values $obj->array), 'List: each $obj->array');
375
376 # Each -- vivification
377 undef $empty;
378 eval { each $empty->{hash} };
379 ok(defined $empty,
380   'Vivify: $empty (after each $empty->{hash}) is HASHREF');
381 ok(!defined $empty->{hash}      ,   'Vivify: $empty->{hash} is undef');
382
383 # Each -- errors
384 $errpat = qr/
385  (?-x:Type of argument to each on reference must be unblessed hashref or)
386  (?-x: arrayref)
387 /x;
388
389 eval "each undef";
390 ok($@ =~ $errpat,
391   'Errors: each undef throws error'
392 );
393
394 undef $empty;
395 eval q"each $empty";
396 ok($@ =~ $errpat,
397   'Errors: each $undef throws error'
398 );
399
400 is($empty, undef, 'each $undef does not vivify $undef');
401
402 eval "each 3";
403 ok($@ =~ qr/Type of arg 1 to each must be hash/,
404   'Errors: each CONSTANT throws error'
405 );
406
407 eval "each qr/foo/";
408 ok($@ =~ $errpat,
409   'Errors: each qr/foo/ throws error'
410 );
411
412 eval "each $hash qw/foo bar/";
413 ok($@ =~ qr/syntax error/,
414   'Errors: each $hash, @stuff throws error'
415 ) or print "# Got: $@";
416
417 # Overloaded objects
418 my $over_a = Foo::Overload::Array->new;
419 my $over_h = Foo::Overload::Hash->new;
420 my $over_b = Foo::Overload::Both->new;
421 my $over_h_a = Foo::Overload::HashOnArray->new;
422 my $over_a_h = Foo::Overload::ArrayOnHash->new;
423
424 {
425   my $warn = '';
426   local $SIG{__WARN__} = sub { $warn = shift };
427
428   $errpat = qr/
429    (?-x:Type of argument to keys on reference must be unblessed hashref or)
430    (?-x: arrayref)
431   /x;
432
433   eval { keys $over_a };
434   like($@, $errpat, "Overload: array dereference");
435   is($warn, '', "no warning issued"); $warn = '';
436
437   eval { keys $over_h };
438   like($@, $errpat, "Overload: hash dereference");
439   is($warn, '', "no warning issued"); $warn = '';
440
441   eval { keys $over_b };
442   like($@, $errpat, "Overload: ambiguous dereference (both)");
443   is($warn, '', "no warning issued"); $warn = '';
444
445   eval { keys $over_h_a };
446   like($@, $errpat, "Overload: ambiguous dereference");
447   is($warn, '', "no warning issued"); $warn = '';
448
449   eval { keys $over_a_h };
450   like($@, $errpat, "Overload: ambiguous dereference");
451   is($warn, '', "no warning issued"); $warn = '';
452 }