1#!./perl 2 3BEGIN { 4 chdir 't' if -d 't'; 5 require './test.pl'; 6 set_up_inc('../lib', '.'); 7} 8# Avoid using eq_array below as it uses .. internally. 9 10use Config; 11 12plan (162); 13 14is(join(':',1..5), '1:2:3:4:5'); 15 16@foo = (1,2,3,4,5,6,7,8,9); 17@foo[2..4] = ('c','d','e'); 18 19is(join(':',@foo[$foo[0]..5]), '2:c:d:e:6'); 20 21@bar[2..4] = ('c','d','e'); 22is(join(':',@bar[1..5]), ':c:d:e:'); 23 24($a,@bcd[0..2],$e) = ('a','b','c','d','e'); 25is(join(':',$a,@bcd[0..2],$e), 'a:b:c:d:e'); 26 27$x = 0; 28for (1..100) { 29 $x += $_; 30} 31is($x, 5050); 32 33$x = 0; 34for ((100,2..99,1)) { 35 $x += $_; 36} 37is($x, 5050); 38 39$x = join('','a'..'z'); 40is($x, 'abcdefghijklmnopqrstuvwxyz'); 41 42@x = 'A'..'ZZ'; 43is (scalar @x, 27 * 26); 44 45foreach (0, 1) { 46 use feature 'unicode_strings'; 47 $s = "a"; 48 $e = "\xFF"; 49 utf8::upgrade($e) if $_; 50 @x = $s .. $e; 51 is (scalar @x, 26, "list-context range with rhs 0xFF, utf8=$_"); 52 @y = (); 53 foreach ($s .. $e) { 54 push @y, $_; 55 } 56 is(join(",", @y), join(",", @x), "foreach range with rhs 0xFF, utf8=$_"); 57} 58 59@x = '09' .. '08'; # should produce '09', '10',... '99' (strange but true) 60is(join(",", @x), join(",", map {sprintf "%02d",$_} 9..99)); 61 62# same test with foreach (which is a separate implementation) 63@y = (); 64foreach ('09'..'08') { 65 push(@y, $_); 66} 67is(join(",", @y), join(",", @x)); 68 69# check bounds 70if ($Config{ivsize} == 8) { 71 @a = eval "0x7ffffffffffffffe..0x7fffffffffffffff"; 72 $a = "9223372036854775806 9223372036854775807"; 73 @b = eval "-0x7fffffffffffffff..-0x7ffffffffffffffe"; 74 $b = "-9223372036854775807 -9223372036854775806"; 75} 76else { 77 @a = eval "0x7ffffffe..0x7fffffff"; 78 $a = "2147483646 2147483647"; 79 @b = eval "-0x7fffffff..-0x7ffffffe"; 80 $b = "-2147483647 -2147483646"; 81} 82 83is ("@a", $a); 84 85is ("@b", $b); 86 87# check magic 88{ 89 my $bad = 0; 90 local $SIG{'__WARN__'} = sub { $bad = 1 }; 91 my $x = 'a-e'; 92 $x =~ s/(\w)-(\w)/join ':', $1 .. $2/e; 93 is ($x, 'a:b:c:d:e'); 94} 95 96# Should use magical autoinc only when both are strings 97{ 98 my $scalar = (() = "0"..-1); 99 is ($scalar, 0); 100} 101{ 102 my $fail = 0; 103 for my $x ("0"..-1) { 104 $fail++; 105 } 106 is ($fail, 0); 107} 108 109# [#18165] Should allow "-4".."0", broken by #4730. (AMS 20021031) 110is(join(":","-4".."0") , "-4:-3:-2:-1:0"); 111is(join(":","-4".."-0") , "-4:-3:-2:-1:0"); 112is(join(":","-4\n".."0\n") , "-4:-3:-2:-1:0"); 113is(join(":","-4\n".."-0\n"), "-4:-3:-2:-1:0"); 114 115# [#133695] "0".."-1" should be the same as 0..-1 116is(join(":","-2".."-1") , "-2:-1"); 117is(join(":","-1".."-1") , "-1"); 118is(join(":","0".."-1") , ""); 119is(join(":","1".."-1") , ""); 120 121# these test the statements made in the documentation 122# regarding the rules of string ranges 123is(join(":","-2".."2"), join(":",-2..2)); 124is(join(":","2.18".."3.14"), "2:3"); 125is(join(":","01".."04"), "01:02:03:04"); 126is(join(":","00".."-1"), "00:01:02:03:04:05:06:07:08:09: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"); 127is(join(":","00".."31"), "00:01:02:03:04:05:06:07:08:09:10:11:12:13:14:15:16:17:18:19:20:21:22:23:24:25:26:27:28:29:30:31"); 128is(join(":","ax".."az"), "ax:ay:az"); 129is(join(":","*x".."az"), "*x"); 130is(join(":","A".."Z"), "A:B:C:D:E:F:G:H:I:J:K:L:M:N:O:P:Q:R:S:T:U:V:W:X:Y:Z"); 131is(join(":", 0..9,"a".."f"), "0:1:2:3:4:5:6:7:8:9:a:b:c:d:e:f"); 132is(join(":","a".."--"), join(":","a".."zz")); 133is(join(":","0".."xx"), "0: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"); 134is(join(":","aaa".."--"), ""); 135 136# undef should be treated as 0 for numerical range 137is(join(":",undef..2), '0:1:2'); 138is(join(":",-2..undef), '-2:-1:0'); 139is(join(":",undef..'2'), '0:1:2'); 140is(join(":",'-2'..undef), '-2:-1:0'); 141 142# undef should be treated as "" for magical range 143is(join(":", map "[$_]", "".."B"), '[]'); 144is(join(":", map "[$_]", undef.."B"), '[]'); 145is(join(":", map "[$_]", "B"..""), ''); 146is(join(":", map "[$_]", "B"..undef), ''); 147 148# undef..undef used to segfault 149is(join(":", map "[$_]", undef..undef), '[]'); 150 151# also test undef in foreach loops 152@foo=(); push @foo, $_ for undef..2; 153is(join(":", @foo), '0:1:2'); 154 155@foo=(); push @foo, $_ for -2..undef; 156is(join(":", @foo), '-2:-1:0'); 157 158@foo=(); push @foo, $_ for undef..'2'; 159is(join(":", @foo), '0:1:2'); 160 161@foo=(); push @foo, $_ for '-2'..undef; 162is(join(":", @foo), '-2:-1:0'); 163 164@foo=(); push @foo, $_ for undef.."B"; 165is(join(":", map "[$_]", @foo), '[]'); 166 167@foo=(); push @foo, $_ for "".."B"; 168is(join(":", map "[$_]", @foo), '[]'); 169 170@foo=(); push @foo, $_ for "B"..undef; 171is(join(":", map "[$_]", @foo), ''); 172 173@foo=(); push @foo, $_ for "B"..""; 174is(join(":", map "[$_]", @foo), ''); 175 176@foo=(); push @foo, $_ for undef..undef; 177is(join(":", map "[$_]", @foo), '[]'); 178 179# again with magic 180{ 181 my @a = (1..3); 182 @foo=(); push @foo, $_ for undef..$#a; 183 is(join(":", @foo), '0:1:2'); 184} 185{ 186 my @a = (); 187 @foo=(); push @foo, $_ for $#a..undef; 188 is(join(":", @foo), '-1:0'); 189} 190{ 191 local $1; 192 "2" =~ /(.+)/; 193 @foo=(); push @foo, $_ for undef..$1; 194 is(join(":", @foo), '0:1:2'); 195} 196{ 197 local $1; 198 "-2" =~ /(.+)/; 199 @foo=(); push @foo, $_ for $1..undef; 200 is(join(":", @foo), '-2:-1:0'); 201} 202{ 203 local $1; 204 "B" =~ /(.+)/; 205 @foo=(); push @foo, $_ for undef..$1; 206 is(join(":", map "[$_]", @foo), '[]'); 207} 208{ 209 local $1; 210 "B" =~ /(.+)/; 211 @foo=(); push @foo, $_ for ""..$1; 212 is(join(":", map "[$_]", @foo), '[]'); 213} 214{ 215 local $1; 216 "B" =~ /(.+)/; 217 @foo=(); push @foo, $_ for $1..undef; 218 is(join(":", map "[$_]", @foo), ''); 219} 220{ 221 local $1; 222 "B" =~ /(.+)/; 223 @foo=(); push @foo, $_ for $1..""; 224 is(join(":", map "[$_]", @foo), ''); 225} 226 227# Test upper range limit 228my $MAX_INT = ~0>>1; 229 230foreach my $ii (-3 .. 3) { 231 my ($first, $last); 232 eval { 233 my $lim=0; 234 for ($MAX_INT-10 .. $MAX_INT+$ii) { 235 if (! defined($first)) { 236 $first = $_; 237 } 238 $last = $_; 239 last if ($lim++ > 100); # Protect against integer wrap 240 } 241 }; 242 if ($ii <= 0) { 243 ok(! $@, 'Upper bound accepted: ' . ($MAX_INT+$ii)); 244 is($first, $MAX_INT-10, 'Lower bound okay'); 245 is($last, $MAX_INT+$ii, 'Upper bound okay'); 246 } else { 247 ok($@, 'Upper bound rejected: ' . ($MAX_INT+$ii)); 248 } 249} 250 251foreach my $ii (-3 .. 3) { 252 my ($first, $last); 253 eval { 254 my $lim=0; 255 for ($MAX_INT+$ii .. $MAX_INT) { 256 if (! defined($first)) { 257 $first = $_; 258 } 259 $last = $_; 260 last if ($lim++ > 100); 261 } 262 }; 263 if ($ii <= 0) { 264 ok(! $@, 'Lower bound accepted: ' . ($MAX_INT+$ii)); 265 is($first, $MAX_INT+$ii, 'Lower bound okay'); 266 is($last, $MAX_INT, 'Upper bound okay'); 267 } else { 268 ok($@, 'Lower bound rejected: ' . ($MAX_INT+$ii)); 269 } 270} 271 272{ 273 my $first; 274 eval { 275 my $lim=0; 276 for ($MAX_INT .. $MAX_INT-1) { 277 if (! defined($first)) { 278 $first = $_; 279 } 280 $last = $_; 281 last if ($lim++ > 100); 282 } 283 }; 284 ok(! $@, 'Range accepted'); 285 ok(! defined($first), 'Range ineffectual'); 286} 287 288foreach my $ii (~0, ~0+1, ~0+(~0>>4)) { 289 eval { 290 my $lim=0; 291 for ($MAX_INT-10 .. $ii) { 292 last if ($lim++ > 100); 293 } 294 }; 295 ok($@, 'Upper bound rejected: ' . $ii); 296} 297 298# Test lower range limit 299my $MIN_INT = -1-$MAX_INT; 300 301if (! $Config{d_nv_preserves_uv}) { 302 # $MIN_INT needs adjustment when IV won't fit into an NV 303 my $NV = $MIN_INT - 1; 304 my $OFFSET = 1; 305 while (($NV + $OFFSET) == $MIN_INT) { 306 $OFFSET++ 307 } 308 $MIN_INT += $OFFSET; 309} 310 311foreach my $ii (-3 .. 3) { 312 my ($first, $last); 313 eval { 314 my $lim=0; 315 for ($MIN_INT+$ii .. $MIN_INT+10) { 316 if (! defined($first)) { 317 $first = $_; 318 } 319 $last = $_; 320 last if ($lim++ > 100); 321 } 322 }; 323 if ($ii >= 0) { 324 ok(! $@, 'Lower bound accepted: ' . ($MIN_INT+$ii)); 325 is($first, $MIN_INT+$ii, 'Lower bound okay'); 326 is($last, $MIN_INT+10, 'Upper bound okay'); 327 } else { 328 ok($@, 'Lower bound rejected: ' . ($MIN_INT+$ii)); 329 } 330} 331 332foreach my $ii (-3 .. 3) { 333 my ($first, $last); 334 eval { 335 my $lim=0; 336 for ($MIN_INT .. $MIN_INT+$ii) { 337 if (! defined($first)) { 338 $first = $_; 339 } 340 $last = $_; 341 last if ($lim++ > 100); 342 } 343 }; 344 if ($ii >= 0) { 345 ok(! $@, 'Upper bound accepted: ' . ($MIN_INT+$ii)); 346 is($first, $MIN_INT, 'Lower bound okay'); 347 is($last, $MIN_INT+$ii, 'Upper bound okay'); 348 } else { 349 ok($@, 'Upper bound rejected: ' . ($MIN_INT+$ii)); 350 } 351} 352 353{ 354 my $first; 355 eval { 356 my $lim=0; 357 for ($MIN_INT+1 .. $MIN_INT) { 358 if (! defined($first)) { 359 $first = $_; 360 } 361 $last = $_; 362 last if ($lim++ > 100); 363 } 364 }; 365 ok(! $@, 'Range accepted'); 366 ok(! defined($first), 'Range ineffectual'); 367} 368 369foreach my $ii (~0, ~0+1, ~0+(~0>>4)) { 370 eval { 371 my $lim=0; 372 for (-$ii .. $MIN_INT+10) { 373 last if ($lim++ > 100); 374 } 375 }; 376 ok($@, 'Lower bound rejected: ' . -$ii); 377} 378 379# double/triple magic tests 380sub TIESCALAR { bless { value => $_[1], orig => $_[1] } } 381sub STORE { $_[0]{store}++; $_[0]{value} = $_[1] } 382sub FETCH { $_[0]{fetch}++; $_[0]{value} } 383sub stores { tied($_[0])->{value} = tied($_[0])->{orig}; 384 delete(tied($_[0])->{store}) || 0 } 385sub fetches { delete(tied($_[0])->{fetch}) || 0 } 386 387tie $x, "main", 6; 388 389my @foo; 390@foo = 4 .. $x; 391is(scalar @foo, 3); 392is("@foo", "4 5 6"); 393is(fetches($x), 1); 394is(stores($x), 0); 395 396@foo = $x .. 8; 397is(scalar @foo, 3); 398is("@foo", "6 7 8"); 399is(fetches($x), 1); 400is(stores($x), 0); 401 402@foo = $x .. $x + 1; 403is(scalar @foo, 2); 404is("@foo", "6 7"); 405is(fetches($x), 2); 406is(stores($x), 0); 407 408@foo = (); 409for (4 .. $x) { 410 push @foo, $_; 411} 412is(scalar @foo, 3); 413is("@foo", "4 5 6"); 414is(fetches($x), 1); 415is(stores($x), 0); 416 417@foo = (); 418for (reverse 4 .. $x) { 419 push @foo, $_; 420} 421is(scalar @foo, 3); 422is("@foo", "6 5 4"); 423is(fetches($x), 1); 424is(stores($x), 0); 425 426is( ( join ' ', map { join '', map ++$_, ($x=1)..4 } 1..2 ), '2345 2345', 427 'modifiable variable num range' ); 428is( ( join ' ', map { join '', map ++$_, 1..4 } 1..2 ), '2345 2345', 429 'modifiable const num range' ); # RT#3105 430$s = ''; for (1..2) { for (1..4) { $s .= ++$_ } $s.=' ' if $_==1; } 431is( $s, '2345 2345','modifiable num counting loop counter' ); 432 433 434is( ( join ' ', map { join '', map ++$_, ($x='a')..'d' } 1..2 ), 'bcde bcde', 435 'modifiable variable alpha range' ); 436is( ( join ' ', map { join '', map ++$_, 'a'..'d' } 1..2 ), 'bcde bcde', 437 'modifiable const alpha range' ); # RT#3105 438$s = ''; for (1..2) { for ('a'..'d') { $s .= ++$_ } $s.=' ' if $_==1; } 439is( $s, 'bcde bcde','modifiable alpha counting loop counter' ); 440 441# RT #130841 442# generating an extreme range triggered a croak, which if caught, 443# left the temps stack small but with a very large PL_tmps_max 444 445SKIP: { 446 skip 'mem wrap check disabled' unless $Config{usemallocwrap}; 447 fresh_perl_like(<<'EOF', qr/\Aok 1 ok 2\Z/, {}, "RT #130841"); 448my $max_iv = (~0 >> 1); 449eval { 450 my @range = 1..($max_iv - 1); 451}; 452if ($@ =~ /panic: memory wrap|Out of memory/) { 453 print "ok 1"; 454} 455else { 456 print "unexpected err status: [$@]"; 457} 458 459# create and push lots of temps 460my $max = 10_000; 461my @ints = map $_+1, 0..($max-1); 462my $sum = 0; 463$sum += $_ for @ints; 464my $exp = $max*($max+1)/2; 465if ($sum == $exp) { 466 print " ok 2"; 467} 468else { 469 print " unexpected sum: [$sum]; expected: [$exp]"; 470} 471EOF 472} 473