1#!./perl -w 2 3BEGIN { 4 chdir 't' if -d 't'; 5 require './test.pl'; 6 set_up_inc('../lib'); 7} 8 9# use strict; 10 11plan tests => 309; 12 13my @comma = ("key", "value"); 14 15# The peephole optimiser already knows that it should convert the string in 16# $foo{string} into a shared hash key scalar. It might be worth making the 17# tokeniser build the LHS of => as a shared hash key scalar too. 18# And so there's the possiblility of it going wrong 19# And going right on 8 bit but wrong on utf8 keys. 20# And really we should also try utf8 literals in {} and => in utf8.t 21 22# Some of these tests are (effectively) duplicated in each.t 23my %comma = @comma; 24ok (keys %comma == 1, 'keys on comma hash'); 25ok (values %comma == 1, 'values on comma hash'); 26# defeat any tokeniser or optimiser cunning 27my $key = 'ey'; 28is ($comma{"k" . $key}, "value", 'is key present? (unoptimised)'); 29# now with cunning: 30is ($comma{key}, "value", 'is key present? (maybe optimised)'); 31#tokeniser may treat => differently. 32my @temp = (key=>undef); 33is ($comma{$temp[0]}, "value", 'is key present? (using LHS of =>)'); 34 35@temp = %comma; 36ok (eq_array (\@comma, \@temp), 'list from comma hash'); 37 38@temp = each %comma; 39ok (eq_array (\@comma, \@temp), 'first each from comma hash'); 40@temp = each %comma; 41ok (eq_array ([], \@temp), 'last each from comma hash'); 42 43my %temp = %comma; 44 45ok (keys %temp == 1, 'keys on copy of comma hash'); 46ok (values %temp == 1, 'values on copy of comma hash'); 47is ($temp{'k' . $key}, "value", 'is key present? (unoptimised)'); 48# now with cunning: 49is ($temp{key}, "value", 'is key present? (maybe optimised)'); 50@temp = (key=>undef); 51is ($comma{$temp[0]}, "value", 'is key present? (using LHS of =>)'); 52 53@temp = %temp; 54ok (eq_array (\@temp, \@temp), 'list from copy of comma hash'); 55 56@temp = each %temp; 57ok (eq_array (\@temp, \@temp), 'first each from copy of comma hash'); 58@temp = each %temp; 59ok (eq_array ([], \@temp), 'last each from copy of comma hash'); 60 61my @arrow = (Key =>"Value"); 62 63my %arrow = @arrow; 64ok (keys %arrow == 1, 'keys on arrow hash'); 65ok (values %arrow == 1, 'values on arrow hash'); 66# defeat any tokeniser or optimiser cunning 67$key = 'ey'; 68is ($arrow{"K" . $key}, "Value", 'is key present? (unoptimised)'); 69# now with cunning: 70is ($arrow{Key}, "Value", 'is key present? (maybe optimised)'); 71#tokeniser may treat => differently. 72@temp = ('Key', undef); 73is ($arrow{$temp[0]}, "Value", 'is key present? (using LHS of =>)'); 74 75@temp = %arrow; 76ok (eq_array (\@arrow, \@temp), 'list from arrow hash'); 77 78@temp = each %arrow; 79ok (eq_array (\@arrow, \@temp), 'first each from arrow hash'); 80@temp = each %arrow; 81ok (eq_array ([], \@temp), 'last each from arrow hash'); 82 83%temp = %arrow; 84 85ok (keys %temp == 1, 'keys on copy of arrow hash'); 86ok (values %temp == 1, 'values on copy of arrow hash'); 87is ($temp{'K' . $key}, "Value", 'is key present? (unoptimised)'); 88# now with cunning: 89is ($temp{Key}, "Value", 'is key present? (maybe optimised)'); 90@temp = ('Key', undef); 91is ($arrow{$temp[0]}, "Value", 'is key present? (using LHS of =>)'); 92 93@temp = %temp; 94ok (eq_array (\@temp, \@temp), 'list from copy of arrow hash'); 95 96@temp = each %temp; 97ok (eq_array (\@temp, \@temp), 'first each from copy of arrow hash'); 98@temp = each %temp; 99ok (eq_array ([], \@temp), 'last each from copy of arrow hash'); 100 101my %direct = ('Camel', 2, 'Dromedary', 1); 102my %slow; 103$slow{Dromedary} = 1; 104$slow{Camel} = 2; 105 106ok (eq_hash (\%slow, \%direct), "direct list assignment to hash"); 107%direct = (Camel => 2, 'Dromedary' => 1); 108ok (eq_hash (\%slow, \%direct), "direct list assignment to hash using =>"); 109 110$slow{Llama} = 0; # A llama is not a camel :-) 111ok (!eq_hash (\%direct, \%slow), "different hashes should not be equal!"); 112 113my (%names, %names_copy); 114%names = ('$' => 'Scalar', '@' => 'Array', # Grr ' 115 '%', 'Hash', '&', 'Code'); 116%names_copy = %names; 117ok (eq_hash (\%names, \%names_copy), "check we can copy our hash"); 118 119sub in { 120 my %args = @_; 121 return eq_hash (\%names, \%args); 122} 123 124ok (in (%names), "pass hash into a method"); 125 126sub in_method { 127 my $self = shift; 128 my %args = @_; 129 return eq_hash (\%names, \%args); 130} 131 132ok (main->in_method (%names), "pass hash into a method"); 133 134sub out { 135 return %names; 136} 137%names_copy = out (); 138 139ok (eq_hash (\%names, \%names_copy), "pass hash from a subroutine"); 140 141sub out_method { 142 my $self = shift; 143 return %names; 144} 145%names_copy = main->out_method (); 146 147ok (eq_hash (\%names, \%names_copy), "pass hash from a method"); 148 149sub in_out { 150 my %args = @_; 151 return %args; 152} 153%names_copy = in_out (%names); 154 155ok (eq_hash (\%names, \%names_copy), "pass hash to and from a subroutine"); 156 157sub in_out_method { 158 my $self = shift; 159 my %args = @_; 160 return %args; 161} 162%names_copy = main->in_out_method (%names); 163 164ok (eq_hash (\%names, \%names_copy), "pass hash to and from a method"); 165 166my %names_copy2 = %names; 167ok (eq_hash (\%names, \%names_copy2), "check copy worked"); 168 169# This should get ignored. 170%names_copy = ('%', 'Associative Array', %names); 171 172ok (eq_hash (\%names, \%names_copy), "duplicates at the start of a list"); 173 174# This should not 175%names_copy = ('*', 'Typeglob', %names); 176 177$names_copy2{'*'} = 'Typeglob'; 178ok (eq_hash (\%names_copy, \%names_copy2), "duplicates at the end of a list"); 179 180%names_copy = ('%', 'Associative Array', '*', 'Endangered species', %names, 181 '*', 'Typeglob',); 182 183ok (eq_hash (\%names_copy, \%names_copy2), "duplicates at both ends"); 184 185# And now UTF8 186 187foreach my $chr (60, 200, 600, 6000, 60000) { 188 # This little game may set a UTF8 flag internally. Or it may not. :-) 189 my ($key, $value) = (chr ($chr) . "\x{ABCD}", "$chr\x{ABCD}"); 190 chop ($key, $value); 191 my @utf8c = ($key, $value); 192 my %utf8c = @utf8c; 193 194 ok (keys %utf8c == 1, 'keys on utf8 comma hash'); 195 ok (values %utf8c == 1, 'values on utf8 comma hash'); 196 # defeat any tokeniser or optimiser cunning 197 is ($utf8c{"" . $key}, $value, 'is key present? (unoptimised)'); 198 my $tempval = sprintf '$utf8c{"\x{%x}"}', $chr; 199 is (eval $tempval, $value, "is key present? (maybe $tempval is optimised)"); 200 $tempval = sprintf '@temp = ("\x{%x}" => undef)', $chr; 201 eval $tempval or die "'$tempval' gave $@"; 202 is ($utf8c{$temp[0]}, $value, 'is key present? (using LHS of $tempval)'); 203 204 @temp = %utf8c; 205 ok (eq_array (\@utf8c, \@temp), 'list from utf8 comma hash'); 206 207 @temp = each %utf8c; 208 ok (eq_array (\@utf8c, \@temp), 'first each from utf8 comma hash'); 209 @temp = each %utf8c; 210 ok (eq_array ([], \@temp), 'last each from utf8 comma hash'); 211 212 %temp = %utf8c; 213 214 ok (keys %temp == 1, 'keys on copy of utf8 comma hash'); 215 ok (values %temp == 1, 'values on copy of utf8 comma hash'); 216 is ($temp{"" . $key}, $value, 'is key present? (unoptimised)'); 217 $tempval = sprintf '$temp{"\x{%x}"}', $chr; 218 is (eval $tempval, $value, "is key present? (maybe $tempval is optimised)"); 219 $tempval = sprintf '@temp = ("\x{%x}" => undef)', $chr; 220 eval $tempval or die "'$tempval' gave $@"; 221 is ($temp{$temp[0]}, $value, "is key present? (using LHS of $tempval)"); 222 223 @temp = %temp; 224 ok (eq_array (\@temp, \@temp), 'list from copy of utf8 comma hash'); 225 226 @temp = each %temp; 227 ok (eq_array (\@temp, \@temp), 'first each from copy of utf8 comma hash'); 228 @temp = each %temp; 229 ok (eq_array ([], \@temp), 'last each from copy of utf8 comma hash'); 230 231 my $assign = sprintf '("\x{%x}" => "%d")', $chr, $chr; 232 print "# $assign\n"; 233 my (@utf8a) = eval $assign; 234 235 my %utf8a = @utf8a; 236 ok (keys %utf8a == 1, 'keys on utf8 arrow hash'); 237 ok (values %utf8a == 1, 'values on utf8 arrow hash'); 238 # defeat any tokeniser or optimiser cunning 239 is ($utf8a{$key . ""}, $value, 'is key present? (unoptimised)'); 240 $tempval = sprintf '$utf8a{"\x{%x}"}', $chr; 241 is (eval $tempval, $value, "is key present? (maybe $tempval is optimised)"); 242 $tempval = sprintf '@temp = ("\x{%x}" => undef)', $chr; 243 eval $tempval or die "'$tempval' gave $@"; 244 is ($utf8a{$temp[0]}, $value, "is key present? (using LHS of $tempval)"); 245 246 @temp = %utf8a; 247 ok (eq_array (\@utf8a, \@temp), 'list from utf8 arrow hash'); 248 249 @temp = each %utf8a; 250 ok (eq_array (\@utf8a, \@temp), 'first each from utf8 arrow hash'); 251 @temp = each %utf8a; 252 ok (eq_array ([], \@temp), 'last each from utf8 arrow hash'); 253 254 %temp = %utf8a; 255 256 ok (keys %temp == 1, 'keys on copy of utf8 arrow hash'); 257 ok (values %temp == 1, 'values on copy of utf8 arrow hash'); 258 is ($temp{'' . $key}, $value, 'is key present? (unoptimised)'); 259 $tempval = sprintf '$temp{"\x{%x}"}', $chr; 260 is (eval $tempval, $value, "is key present? (maybe $tempval is optimised)"); 261 $tempval = sprintf '@temp = ("\x{%x}" => undef)', $chr; 262 eval $tempval or die "'$tempval' gave $@"; 263 is ($temp{$temp[0]}, $value, "is key present? (using LHS of $tempval)"); 264 265 @temp = %temp; 266 ok (eq_array (\@temp, \@temp), 'list from copy of utf8 arrow hash'); 267 268 @temp = each %temp; 269 ok (eq_array (\@temp, \@temp), 'first each from copy of utf8 arrow hash'); 270 @temp = each %temp; 271 ok (eq_array ([], \@temp), 'last each from copy of utf8 arrow hash'); 272 273} 274 275# now some tests for hash assignment in scalar and list context with 276# duplicate keys [perl #24380], [perl #31865] 277{ 278 my %h; my $x; my $ar; 279 is( (join ':', %h = (1) x 8), '1:1', 280 'hash assignment in list context removes duplicates' ); 281 is( (join ':', %h = qw(a 1 a 2 b 3 c 4 d 5 d 6)), 'a:2:b:3:c:4:d:6', 282 'hash assignment in list context removes duplicates 2' ); 283 is( scalar( %h = (1,2,1,3,1,4,1,5) ), 8, 284 'hash assignment in scalar context' ); 285 is( scalar( ($x,%h) = (0,1,2,1,3,1,4,1,5) ), 9, 286 'scalar + hash assignment in scalar context' ); 287 $ar = [ %h = (1,2,1,3,1,4,1,5) ]; 288 is( $#$ar, 1, 'hash assignment in list context' ); 289 is( "@$ar", "1 5", '...gets the last values' ); 290 $ar = [ ($x,%h) = (0,1,2,1,3,1,4,1,5) ]; 291 is( $#$ar, 2, 'scalar + hash assignment in list context' ); 292 is( "@$ar", "0 1 5", '...gets the last values' ); 293} 294 295# test stringification of keys 296{ 297 no warnings 'once'; 298 my @types = qw( SCALAR ARRAY HASH CODE GLOB); 299 my @refs = ( \ do { my $x }, [], {}, sub {}, \ *x); 300 my(%h, %expect); 301 @h{@refs} = @types; 302 @expect{map "$_", @refs} = @types; 303 ok (eq_hash(\%h, \%expect), 'unblessed ref stringification'); 304 305 bless $_ for @refs; 306 %h = (); %expect = (); 307 @h{@refs} = @types; 308 @expect{map "$_", @refs} = @types; 309 ok (eq_hash(\%h, \%expect), 'blessed ref stringification'); 310} 311 312# [perl #76716] Hash assignment should not zap weak refs. 313{ 314 my %tb; 315 no warnings 'experimental::builtin'; 316 use builtin 'weaken'; 317 weaken(my $p = \%tb); 318 %tb = (); 319 is $p, \%tb, "hash assignment should not zap weak refs"; 320 undef %tb; 321 is $p, \%tb, "hash undef should not zap weak refs"; 322} 323 324# test odd hash assignment warnings 325{ 326 my ($s, %h); 327 warning_like(sub {%h = (1..3)}, qr/^Odd number of elements in hash assignment/); 328 warning_like(sub {%h = ({})}, qr/^Reference found where even-sized list expected/); 329 330 warning_like(sub { ($s, %h) = (1..4)}, qr/^Odd number of elements in hash assignment/); 331 warning_like(sub { ($s, %h) = (1, {})}, qr/^Reference found where even-sized list expected/); 332} 333 334# hash assignment in scalar and list context with odd number of elements 335{ 336 no warnings 'misc', 'uninitialized'; 337 my %h; my $x; 338 is( join( ':', %h = (1..3)), '1:2:3:', 339 'odd hash assignment in list context' ); 340 ok( eq_hash( \%h, {1 => 2, 3 => undef} ), "correct value stored" ); 341 is( scalar( %h = (1..3) ), 3, 342 'odd hash assignment in scalar context' ); 343 ok( eq_hash( \%h, {1 => 2, 3 => undef} ), "correct value stored" ); 344 is( join(':', ($x,%h) = (0,1,2,3) ), '0:1:2:3:', 345 'scalar + odd hash assignment in list context' ); 346 ok( eq_hash( \%h, {1 => 2, 3 => undef} ), "correct value stored" ); 347 is( scalar( ($x,%h) = (0,1,2,3) ), 4, 348 'scalar + odd hash assignment in scalar context' ); 349 ok( eq_hash( \%h, {1 => 2, 3 => undef} ), "correct value stored" ); 350} 351 352# hash assignment in scalar and list context with odd number of elements 353# and duplicates 354{ 355 no warnings 'misc', 'uninitialized'; 356 my %h; my $x; 357 is( (join ':', %h = (1,1,1)), '1:', 358 'odd hash assignment in list context with duplicates' ); 359 ok( eq_hash( \%h, {1 => undef} ), "correct value stored" ); 360 is( scalar(%h = (1,1,1)), 3, 361 'odd hash assignment in scalar context with duplicates' ); 362 ok( eq_hash( \%h, {1 => undef} ), "correct value stored" ); 363 is( join(':', ($x,%h) = (0,1,1,1) ), '0:1:', 364 'scalar + odd hash assignment in list context with duplicates' ); 365 ok( eq_hash( \%h, {1 => undef} ), "correct value stored" ); 366 is( scalar( ($x,%h) = (0,1,1,1) ), 4, 367 'scalar + odd hash assignment in scalar context with duplicates' ); 368 ok( eq_hash( \%h, {1 => undef} ), "correct value stored" ); 369} 370 371# hash followed by more elements on LHS of list assignment 372# (%h, ...) = ...; 373{ 374 my (%h, %x, @x, $x); 375 is( scalar( (%h,$x) = (1,2,3,4)), 4, 376 'hash+scalar assignment in scalar context' ); 377 ok( eq_hash( \%h, {1 => 2, 3 => 4} ), "correct hash" ); 378 is( $x, undef, "correct scalar" ); 379 is( join(':', map $_ // 'undef', ((%h,$x) = (1,2,3,4))), '1:2:3:4:undef', 380 'hash+scalar assignment in list context' ); 381 ok( eq_hash( \%h, {1 => 2, 3 => 4} ), "correct hash" ); 382 is( $x, undef, "correct scalar" ); 383 384 is( scalar( (%h,%x) = (1,2,3,4)), 4, 385 'hash+hash assignment in scalar context' ); 386 ok( eq_hash( \%h, {1 => 2, 3 => 4} ), "correct hash" ); 387 ok( eq_hash( \%x, {} ), "correct hash" ); 388 is( join(':', (%h,%x) = (1,2,3,4)), '1:2:3:4', 389 'hash+hash assignment in list context' ); 390 ok( eq_hash( \%h, {1 => 2, 3 => 4} ), "correct hash" ); 391 ok( eq_hash( \%x, {} ), "correct hash" ); 392 393 is( scalar( (%h,@x) = (1,2,3,4)), 4, 394 'hash+array assignment in scalar context' ); 395 ok( eq_hash( \%h, {1 => 2, 3 => 4} ), "correct hash" ); 396 ok( eq_array( \@x, [] ), "correct array" ); 397 is( join(':', (%h,@x) = (1,2,3,4)), '1:2:3:4', 398 'hash+hash assignment in list context' ); 399 ok( eq_hash( \%h, {1 => 2, 3 => 4} ), "correct hash" ); 400 ok( eq_array( \@x, [] ), "correct array" ); 401} 402 403# hash followed by more elements on LHS of list assignment 404# and duplicates on RHS 405# (%h, ...) = (1)x10; 406{ 407 my (%h, %x, @x, $x); 408 is( scalar( (%h,$x) = (1,2,1,4)), 4, 409 'hash+scalar assignment in scalar context' ); 410 ok( eq_hash( \%h, {1 => 4} ), "correct hash" ); 411 is( $x, undef, "correct scalar" ); 412 is( join(':', map $_ // 'undef', ((%h,$x) = (1,2,1,4))), '1:4:undef', 413 'hash+scalar assignment in list context' ); 414 ok( eq_hash( \%h, {1 => 4} ), "correct hash" ); 415 is( $x, undef, "correct scalar" ); 416 417 is( scalar( (%h,%x) = (1,2,1,4)), 4, 418 'hash+hash assignment in scalar context' ); 419 ok( eq_hash( \%h, {1 => 4} ), "correct hash" ); 420 ok( eq_hash( \%x, {} ), "correct hash" ); 421 is( join(':', (%h,%x) = (1,2,1,4)), '1:4', 422 'hash+hash assignment in list context' ); 423 ok( eq_hash( \%h, {1 => 4} ), "correct hash" ); 424 ok( eq_hash( \%x, {} ), "correct hash" ); 425 426 is( scalar( (%h,@x) = (1,2,1,4)), 4, 427 'hash+array assignment in scalar context' ); 428 ok( eq_hash( \%h, {1 => 4} ), "correct hash" ); 429 ok( eq_array( \@x, [] ), "correct array" ); 430 is( join(':', (%h,@x) = (1,2,1,4)), '1:4', 431 'hash+hash assignment in list context' ); 432 ok( eq_hash( \%h, {1 => 4} ), "correct hash" ); 433 ok( eq_array( \@x, [] ), "correct array" ); 434} 435 436# hash followed by more elements on LHS of list assignment 437# and duplicates with odd number of elements on RHS 438# (%h, ...) = (1,2,3,4,1); 439{ 440 no warnings 'misc'; # suppress oddball warnings 441 my (%h, %x, @x, $x); 442 is( scalar( (%h,$x) = (1,2,3,4,1)), 5, 443 'hash+scalar assignment in scalar context' ); 444 ok( eq_hash( \%h, {1 => undef, 3 => 4} ), "correct hash" ); 445 is( $x, undef, "correct scalar" ); 446 is( join(':', map $_//'undef', (%h,$x) = (1,2,3,4,1)), '1:undef:3:4:undef', 447 'hash+scalar assignment in list context' ); 448 ok( eq_hash( \%h, {1 => undef, 3 => 4} ), "correct hash" ); 449 is( $x, undef, "correct scalar" ); 450 451 is( scalar( (%h,%x) = (1,2,3,4,1)), 5, 452 'hash+hash assignment in scalar context' ); 453 ok( eq_hash( \%h, {1 => undef, 3 => 4} ), "correct hash" ); 454 ok( eq_hash( \%x, {} ), "correct hash" ); 455 is( join(':', map $_//'undef', (%h,%x) = (1,2,3,4,1)), '1:undef:3:4', 456 'hash+hash assignment in list context' ); 457 ok( eq_hash( \%h, {1 => undef, 3 => 4} ), "correct hash" ); 458 ok( eq_hash( \%x, {} ), "correct hash" ); 459 460 is( scalar( (%h,@x) = (1,2,3,4,1)), 5, 461 'hash+array assignment in scalar context' ); 462 ok( eq_hash( \%h, {1 => undef, 3 => 4} ), "correct hash" ); 463 ok( eq_array( \@x, [] ), "correct array" ); 464 is( join(':', map $_//'undef', (%h,@x) = (1,2,3,4,1)), '1:undef:3:4', 465 'hash+hash assignment in list context' ); 466 ok( eq_hash( \%h, {1 => undef, 3 => 4} ), "correct hash" ); 467 ok( eq_array( \@x, [] ), "correct array" ); 468} 469 470 471# not enough elements on rhs 472# ($x,$y,$z,...) = (1); 473{ 474 my ($x,$y,$z,@a,%h); 475 is( join(':', map $_ // 'undef', (($x, $y, %h) = (1))), '1:undef', 476 'only assigned elements are returned in list context'); 477 is( join(':', ($x, $y, %h) = (1,1)), '1:1', 478 'only assigned elements are returned in list context'); 479 no warnings 'misc'; # suppress oddball warnings 480 is( join(':', map $_//'undef', ($x, $y, %h) = (1,1,1)), '1:1:1:undef', 481 'only assigned elements are returned in list context'); 482 is( join(':', ($x, $y, %h) = (1,1,1,1)), '1:1:1:1', 483 'only assigned elements are returned in list context'); 484 is( join(':', map $_//'undef', ($x, %h, $y) = (1,2,3,4)), 485 '1:2:3:4:undef:undef', 486 'only assigned elements are returned in list context'); 487 is( join(':', map $_//'undef', ($x, $y, @h) = (1)), '1:undef', 488 'only assigned elements are returned in list context'); 489 is( join(':', map $_//'undef', ($x, @h, $y) = (1,2,3,4)), '1:2:3:4:undef', 490 'only assigned elements are returned in list context'); 491} 492 493# lvaluedness of list context 494{ 495 my %h; my ($x, $y, $z); 496 $_++ foreach %h = (1,2,3,4); 497 ok( eq_hash( \%h, {1 => 3, 3 => 5} ), "aassign in list context returns lvalues" ); 498 499 $_++ foreach %h = (1,2,1,4); 500 ok( eq_hash( \%h, {1 => 5} ), "the same for assignment with duplicates" ); 501 502 $_++ foreach ($x, %h) = (0,1,2,3,4); 503 is( $x, 1, "... and leading scalar" ); 504 ok( eq_hash( \%h, {1 => 3, 3 => 5} ), "... scalar followed by hash" ); 505 506 { 507 no warnings 'misc'; 508 $_++ foreach %h = (1,2,3); 509 ok( eq_hash( \%h, {1 => 3, 3 => 1} ), "odd elements also lvalued" ); 510 } 511 512 $x = 0; 513 $_++ foreach %h = ($x,$x); 514 is($x, 0, "returned values are not aliased to RHS of the assignment operation"); 515 516 %h = (); 517 $x = 0; 518 $_++ foreach sub :lvalue { %h = ($x,$x) }->(); 519 is($x, 0, 520 "returned values are not aliased to RHS of assignment in lvalue sub"); 521 522 $_++ foreach ($x,$y,%h,$z) = (0); 523 ok( eq_array([$x,$y,%h,$z], [1,1,1]), "all assigned values are returned" ); 524 525 $_++ foreach ($x,$y,%h,$z) = (0,1); 526 ok( eq_array([$x,$y,%h,$z], [1,2,1]), "all assigned values are returned" ); 527 528 no warnings 'misc'; # suppress oddball warnings 529 $_++ foreach ($x,$y,%h,$z) = (0,1,2); 530 ok( eq_array([$x,$y,%h,$z], [1,2,2,1,1]), "all assigned values are returned" ); 531} 532 533 534