10 no warnings 'uninitialized';
16 # Predeclare vars used in the tests:
19 my @sparse; $sparse[2] = 2;
21 my $deep1 = []; push @$deep1, \$deep1;
22 my $deep2 = []; push @$deep2, \$deep2;
25 tie my @tied_nums, 'Tie::StdArray';
28 my %hash = (foo => 17, bar => 23);
29 tie my %tied_hash, 'Tie::StdHash';
33 package Test::Object::NoOverload;
34 sub new { bless { key => 1 } }
38 package Test::Object::StringOverload;
39 use overload '""' => sub { "object" }, fallback => 1;
40 sub new { bless { key => 1 } }
44 package Test::Object::WithOverload;
45 sub new { bless { key => ($_[1] // 'magic') } }
46 use overload '~~' => sub {
47 my %hash = %{ $_[0] };
48 if ($_[2]) { # arguments reversed ?
49 return $_[1] eq reverse $hash{key};
52 return $_[1] eq $hash{key};
55 use overload '""' => sub { "stringified" };
56 use overload 'eq' => sub {"$_[0]" eq "$_[1]"};
59 our $ov_obj = Test::Object::WithOverload->new;
60 our $ov_obj_2 = Test::Object::WithOverload->new("object");
61 our $obj = Test::Object::NoOverload->new;
62 our $str_obj = Test::Object::StringOverload->new;
64 tie my %refh, 'Tie::RefHash';
67 my @keyandmore = qw(key and more);
68 my @fooormore = qw(foo or more);
69 my %keyandmore = map { $_ => 0 } @keyandmore;
70 my %fooormore = map { $_ => 0 } @fooormore;
72 # Load and run the tests
76 next if /^#/ || !/\S/;
78 my ($yn, $left, $right, $note) = split /\t+/;
80 local $::TODO = $note =~ /TODO/;
82 die "Bad test spec: ($yn, $left, $right)" if $yn =~ /[^!@=]/;
84 my $tstr = "$left ~~ $right";
88 if ($note =~ /NOWARNINGS/) {
89 $res = eval "no warnings; $tstr";
98 ok( $@ ne '', "$tstr dies" )
99 and print "# \$\@ was: $@\n";
101 my $test_name = $tstr . ($yn =~ /!/ ? " does not match" : " matches");
104 print "# \$\@ was: $@\n";
106 ok( ($yn =~ /!/ xor $res), $test_name );
110 if ( $yn =~ s/=// ) {
111 $tstr = "$right ~~ $left";
119 sub fatal {die "fatal sub\n"}
121 # to test constant folding
124 sub NOT_DEF() { undef }
127 # - expected to match
128 # ! - expected to not match
129 # @ - expected to be a compilation failure
130 # = - expected to match symmetrically (runs test twice)
131 # Data types to test :
140 # Tied arrays and hashes
141 # Arrays that reference themselves
142 # Regex (// and qr//)
146 # Other syntactic items of interest:
148 # Values returned by a sub call
175 # Any ~~ object overloaded
180 ! ['stringified'] $ov_obj
181 ! { cigam => 1 } $ov_obj
182 ! { stringified => 1 } $ov_obj
203 # regular object with "" overload
210 @ %keyandmore $str_obj
211 @ {"object" => 1} $str_obj
212 @ @fooormore $str_obj
213 @ ["object" => 1] $str_obj
215 @ qr/object/ $str_obj
218 # Those will treat the $str_obj as a string because of fallback:
222 # object (overloaded or not) ~~ Any
224 $ov_obj qr/^stringified$/
225 = "$ov_obj" "stringified"
226 = "$str_obj" "object"
227 != $ov_obj "stringified"
230 ! $ov_obj 'not magic'
233 sub{0} sub { ref $_[0] eq "CODE" }
234 %fooormore sub { $_[0] =~ /^(foo|or|more)$/ }
235 ! %fooormore sub { $_[0] =~ /^(foo|or|less)$/ }
236 \%fooormore sub { $_[0] =~ /^(foo|or|more)$/ }
237 ! \%fooormore sub { $_[0] =~ /^(foo|or|less)$/ }
238 +{%fooormore} sub { $_[0] =~ /^(foo|or|more)$/ }
239 ! +{%fooormore} sub { $_[0] =~ /^(foo|or|less)$/ }
240 @fooormore sub { $_[0] =~ /^(foo|or|more)$/ }
241 ! @fooormore sub { $_[0] =~ /^(foo|or|less)$/ }
242 \@fooormore sub { $_[0] =~ /^(foo|or|more)$/ }
243 ! \@fooormore sub { $_[0] =~ /^(foo|or|less)$/ }
244 [@fooormore] sub { $_[0] =~ /^(foo|or|more)$/ }
245 ! [@fooormore] sub { $_[0] =~ /^(foo|or|less)$/ }
246 %fooormore sub{@_==1}
247 @fooormore sub{@_==1}
248 "foo" sub { $_[0] =~ /^(foo|or|more)$/ }
249 ! "more" sub { $_[0] =~ /^(foo|or|less)$/ }
250 /fooormore/ sub{ref $_[0] eq 'Regexp'}
251 qr/fooormore/ sub{ref $_[0] eq 'Regexp'}
256 NOT_DEF sub{not shift}
257 &NOT_DEF sub{not shift}
264 $obj sub { ref($_[0]) =~ /NoOverload/ }
265 $ov_obj sub { ref($_[0]) =~ /WithOverload/ }
266 # empty stuff matches, because the sub is never called:
280 # sub is not called on empty hashes / arrays
285 # sub is not special on the left
287 sub {0} sub { ref shift eq "CODE" }
296 = \%main:: {map {$_ => 'x'} keys %main::}
300 \%tied_hash \%tied_hash
301 != {"a"=>"b"} \%tied_hash
303 %tied_hash %tied_hash
304 != {"a"=>"b"} %tied_hash
312 # (since this is symmetrical, tests as well hash~~array)
313 = [keys %main::] \%::
314 = [qw[STDIN STDOUT]] \%::
321 = ["foo"] { foo => 1 }
322 = ["foo", "bar"] { foo => 1 }
323 = ["foo", "bar"] \%hash
326 = [qw(foo quux)] \%hash
327 = @fooormore { foo => 1, or => 2, more => 3 }
328 = @fooormore %fooormore
329 = @fooormore \%fooormore
330 = \@fooormore %fooormore
333 = qr/^(fo[ox])$/ {foo => 1}
334 = /^(fo[ox])$/ %fooormore
335 =! qr/[13579]$/ +{0..99}
344 "foo" +{foo => 1, bar => 2}
346 ! "baz" +{foo => 1, bar => 2}
348 ! 1 +{foo => 1, bar => 2}
358 ! undef { hop => 'zouu' }
360 ! undef +{"" => "empty key"}
364 # - another array ref
367 [["foo"], ["bar"]] [qr/o/, qr/a/]
368 ! [["foo"], ["bar"]] [qr/ARRAY/, qr/ARRAY/]
369 ["foo", "bar"] [qr/o/, qr/a/]
370 ! [qr/o/, qr/a/] ["foo", "bar"]
371 ["foo", "bar"] [["foo"], ["bar"]]
372 ! ["foo", "bar"] [qr/o/, "foo"]
373 ["foo", undef, "bar"] [qr/o/, undef, "bar"]
374 ! ["foo", undef, "bar"] [qr/o/, "", "bar"]
375 ! ["foo", "", "bar"] [qr/o/, undef, "bar"]
387 $obj [sub{ref shift}]
390 = qr/x/ [qw(foo bar baz quux)]
391 =! qr/y/ [qw(foo bar baz quux)]
392 = /x/ [qw(foo bar baz quux)]
393 =! /y/ [qw(foo bar baz quux)]
404 ! "2" [qw(1foo 2bar)]
405 "2bar" [qw(1foo 2bar)]
408 undef [1, 2, undef, 4]
409 ! undef [1, 2, [undef], 4]
418 # - nested arrays and ~~ distributivity
421 "foo" [{foo => "bar"}]
422 ! "bar" [{foo => "bar"}]
424 # Number against number
433 # Number against string
437 != 2_3 "2_3" NOWARNINGS
442 # Regex against string
446 # Regex against number
450 # array/hash against string
451 @fooormore "".\@fooormore
452 ! @keyandmore "".\@fooormore
453 %fooormore "".\%fooormore
454 ! %keyandmore "".\%fooormore
456 # Test the implicit referencing
471 %tied_hash %tied_hash
472 %hash { foo => 5, bar => 10 }
473 ! %hash { foo => 5, bar => 10, quux => 15 }
475 @nums { 1, '', 2, '' }
476 @nums { 1, '', 12, '' }
477 ! @nums { 11, '', 12, '' }