This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Call get-magic once for .. in list context
[perl5.git] / t / op / range.t
1 #!./perl
2
3 BEGIN {
4     chdir 't' if -d 't';
5     @INC = ('../lib', '.');
6 }   
7 # Avoid using eq_array below as it uses .. internally.
8 require 'test.pl';
9
10 use Config;
11
12 plan (141);
13
14 is(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
19 is(join(':',@foo[$foo[0]..5]), '2:c:d:e:6');
20
21 @bar[2..4] = ('c','d','e');
22 is(join(':',@bar[1..5]), ':c:d:e:');
23
24 ($a,@bcd[0..2],$e) = ('a','b','c','d','e');
25 is(join(':',$a,@bcd[0..2],$e), 'a:b:c:d:e');
26
27 $x = 0;
28 for (1..100) {
29     $x += $_;
30 }
31 is($x, 5050);
32
33 $x = 0;
34 for ((100,2..99,1)) {
35     $x += $_;
36 }
37 is($x, 5050);
38
39 $x = join('','a'..'z');
40 is($x, 'abcdefghijklmnopqrstuvwxyz');
41
42 @x = 'A'..'ZZ';
43 is (scalar @x, 27 * 26);
44
45 @x = '09' .. '08';  # should produce '09', '10',... '99' (strange but true)
46 is(join(",", @x), join(",", map {sprintf "%02d",$_} 9..99));
47
48 # same test with foreach (which is a separate implementation)
49 @y = ();
50 foreach ('09'..'08') {
51     push(@y, $_);
52 }
53 is(join(",", @y), join(",", @x));
54
55 # check bounds
56 if ($Config{ivsize} == 8) {
57   @a = eval "0x7ffffffffffffffe..0x7fffffffffffffff";
58   $a = "9223372036854775806 9223372036854775807";
59   @b = eval "-0x7fffffffffffffff..-0x7ffffffffffffffe";
60   $b = "-9223372036854775807 -9223372036854775806";
61 }
62 else {
63   @a = eval "0x7ffffffe..0x7fffffff";
64   $a = "2147483646 2147483647";
65   @b = eval "-0x7fffffff..-0x7ffffffe";
66   $b = "-2147483647 -2147483646";
67 }
68
69 is ("@a", $a);
70
71 is ("@b", $b);
72
73 # check magic
74 {
75     my $bad = 0;
76     local $SIG{'__WARN__'} = sub { $bad = 1 };
77     my $x = 'a-e';
78     $x =~ s/(\w)-(\w)/join ':', $1 .. $2/e;
79     is ($x, 'a:b:c:d:e');
80 }
81
82 # Should use magical autoinc only when both are strings
83 {
84     my $scalar = (() = "0"..-1);
85     is ($scalar, 0);
86 }
87 {
88     my $fail = 0;
89     for my $x ("0"..-1) {
90         $fail++;
91     }
92     is ($fail, 0);
93 }
94
95 # [#18165] Should allow "-4".."0", broken by #4730. (AMS 20021031)
96 is(join(":","-4".."0")     , "-4:-3:-2:-1:0");
97 is(join(":","-4".."-0")    , "-4:-3:-2:-1:0");
98 is(join(":","-4\n".."0\n") , "-4:-3:-2:-1:0");
99 is(join(":","-4\n".."-0\n"), "-4:-3:-2:-1:0");
100
101 # undef should be treated as 0 for numerical range
102 is(join(":",undef..2), '0:1:2');
103 is(join(":",-2..undef), '-2:-1:0');
104 is(join(":",undef..'2'), '0:1:2');
105 is(join(":",'-2'..undef), '-2:-1:0');
106
107 # undef should be treated as "" for magical range
108 is(join(":", map "[$_]", "".."B"), '[]');
109 is(join(":", map "[$_]", undef.."B"), '[]');
110 is(join(":", map "[$_]", "B"..""), '');
111 is(join(":", map "[$_]", "B"..undef), '');
112
113 # undef..undef used to segfault
114 is(join(":", map "[$_]", undef..undef), '[]');
115
116 # also test undef in foreach loops
117 @foo=(); push @foo, $_ for undef..2;
118 is(join(":", @foo), '0:1:2');
119
120 @foo=(); push @foo, $_ for -2..undef;
121 is(join(":", @foo), '-2:-1:0');
122
123 @foo=(); push @foo, $_ for undef..'2';
124 is(join(":", @foo), '0:1:2');
125
126 @foo=(); push @foo, $_ for '-2'..undef;
127 is(join(":", @foo), '-2:-1:0');
128
129 @foo=(); push @foo, $_ for undef.."B";
130 is(join(":", map "[$_]", @foo), '[]');
131
132 @foo=(); push @foo, $_ for "".."B";
133 is(join(":", map "[$_]", @foo), '[]');
134
135 @foo=(); push @foo, $_ for "B"..undef;
136 is(join(":", map "[$_]", @foo), '');
137
138 @foo=(); push @foo, $_ for "B".."";
139 is(join(":", map "[$_]", @foo), '');
140
141 @foo=(); push @foo, $_ for undef..undef;
142 is(join(":", map "[$_]", @foo), '[]');
143
144 # again with magic
145 {
146     my @a = (1..3);
147     @foo=(); push @foo, $_ for undef..$#a;
148     is(join(":", @foo), '0:1:2');
149 }
150 {
151     my @a = ();
152     @foo=(); push @foo, $_ for $#a..undef;
153     is(join(":", @foo), '-1:0');
154 }
155 {
156     local $1;
157     "2" =~ /(.+)/;
158     @foo=(); push @foo, $_ for undef..$1;
159     is(join(":", @foo), '0:1:2');
160 }
161 {
162     local $1;
163     "-2" =~ /(.+)/;
164     @foo=(); push @foo, $_ for $1..undef;
165     is(join(":", @foo), '-2:-1:0');
166 }
167 {
168     local $1;
169     "B" =~ /(.+)/;
170     @foo=(); push @foo, $_ for undef..$1;
171     is(join(":", map "[$_]", @foo), '[]');
172 }
173 {
174     local $1;
175     "B" =~ /(.+)/;
176     @foo=(); push @foo, $_ for ""..$1;
177     is(join(":", map "[$_]", @foo), '[]');
178 }
179 {
180     local $1;
181     "B" =~ /(.+)/;
182     @foo=(); push @foo, $_ for $1..undef;
183     is(join(":", map "[$_]", @foo), '');
184 }
185 {
186     local $1;
187     "B" =~ /(.+)/;
188     @foo=(); push @foo, $_ for $1.."";
189     is(join(":", map "[$_]", @foo), '');
190 }
191
192 # Test upper range limit
193 my $MAX_INT = ~0>>1;
194
195 foreach my $ii (-3 .. 3) {
196     my ($first, $last);
197     eval {
198         my $lim=0;
199         for ($MAX_INT-10 .. $MAX_INT+$ii) {
200             if (! defined($first)) {
201                 $first = $_;
202             }
203             $last = $_;
204             last if ($lim++ > 100);   # Protect against integer wrap
205         }
206     };
207     if ($ii <= 0) {
208         ok(! $@, 'Upper bound accepted: ' . ($MAX_INT+$ii));
209         is($first, $MAX_INT-10, 'Lower bound okay');
210         is($last, $MAX_INT+$ii, 'Upper bound okay');
211     } else {
212         ok($@, 'Upper bound rejected: ' . ($MAX_INT+$ii));
213     }
214 }
215
216 foreach my $ii (-3 .. 3) {
217     my ($first, $last);
218     eval {
219         my $lim=0;
220         for ($MAX_INT+$ii .. $MAX_INT) {
221             if (! defined($first)) {
222                 $first = $_;
223             }
224             $last = $_;
225             last if ($lim++ > 100);
226         }
227     };
228     if ($ii <= 0) {
229         ok(! $@, 'Lower bound accepted: ' . ($MAX_INT+$ii));
230         is($first, $MAX_INT+$ii, 'Lower bound okay');
231         is($last, $MAX_INT, 'Upper bound okay');
232     } else {
233         ok($@, 'Lower bound rejected: ' . ($MAX_INT+$ii));
234     }
235 }
236
237 {
238     my $first;
239     eval {
240         my $lim=0;
241         for ($MAX_INT .. $MAX_INT-1) {
242             if (! defined($first)) {
243                 $first = $_;
244             }
245             $last = $_;
246             last if ($lim++ > 100);
247         }
248     };
249     ok(! $@, 'Range accepted');
250     ok(! defined($first), 'Range ineffectual');
251 }
252
253 foreach my $ii (~0, ~0+1, ~0+(~0>>4)) {
254     eval {
255         my $lim=0;
256         for ($MAX_INT-10 .. $ii) {
257             last if ($lim++ > 100);
258         }
259     };
260     ok($@, 'Upper bound rejected: ' . $ii);
261 }
262
263 # Test lower range limit
264 my $MIN_INT = -1-$MAX_INT;
265
266 if (! $Config{d_nv_preserves_uv}) {
267     # $MIN_INT needs adjustment when IV won't fit into an NV
268     my $NV = $MIN_INT - 1;
269     my $OFFSET = 1;
270     while (($NV + $OFFSET) == $MIN_INT) {
271         $OFFSET++
272     }
273     $MIN_INT += $OFFSET;
274 }
275
276 foreach my $ii (-3 .. 3) {
277     my ($first, $last);
278     eval {
279         my $lim=0;
280         for ($MIN_INT+$ii .. $MIN_INT+10) {
281             if (! defined($first)) {
282                 $first = $_;
283             }
284             $last = $_;
285             last if ($lim++ > 100);
286         }
287     };
288     if ($ii >= 0) {
289         ok(! $@, 'Lower bound accepted: ' . ($MIN_INT+$ii));
290         is($first, $MIN_INT+$ii, 'Lower bound okay');
291         is($last, $MIN_INT+10, 'Upper bound okay');
292     } else {
293         ok($@, 'Lower bound rejected: ' . ($MIN_INT+$ii));
294     }
295 }
296
297 foreach my $ii (-3 .. 3) {
298     my ($first, $last);
299     eval {
300         my $lim=0;
301         for ($MIN_INT .. $MIN_INT+$ii) {
302             if (! defined($first)) {
303                 $first = $_;
304             }
305             $last = $_;
306             last if ($lim++ > 100);
307         }
308     };
309     if ($ii >= 0) {
310         ok(! $@, 'Upper bound accepted: ' . ($MIN_INT+$ii));
311         is($first, $MIN_INT, 'Lower bound okay');
312         is($last, $MIN_INT+$ii, 'Upper bound okay');
313     } else {
314         ok($@, 'Upper bound rejected: ' . ($MIN_INT+$ii));
315     }
316 }
317
318 {
319     my $first;
320     eval {
321         my $lim=0;
322         for ($MIN_INT+1 .. $MIN_INT) {
323             if (! defined($first)) {
324                 $first = $_;
325             }
326             $last = $_;
327             last if ($lim++ > 100);
328         }
329     };
330     ok(! $@, 'Range accepted');
331     ok(! defined($first), 'Range ineffectual');
332 }
333
334 foreach my $ii (~0, ~0+1, ~0+(~0>>4)) {
335     eval {
336         my $lim=0;
337         for (-$ii .. $MIN_INT+10) {
338             last if ($lim++ > 100);
339         }
340     };
341     ok($@, 'Lower bound rejected: ' . -$ii);
342 }
343
344 # double/triple magic tests
345 sub TIESCALAR { bless { value => $_[1], orig => $_[1] } }
346 sub STORE { $_[0]{store}++; $_[0]{value} = $_[1] }
347 sub FETCH { $_[0]{fetch}++; $_[0]{value} }
348 sub stores { tied($_[0])->{value} = tied($_[0])->{orig};
349              delete(tied($_[0])->{store}) || 0 }
350 sub fetches { delete(tied($_[0])->{fetch}) || 0 }
351     
352 tie $x, "main", 6;
353
354 my @foo;
355 @foo = 4 .. $x;
356 is(scalar @foo, 3);
357 is("@foo", "4 5 6");
358 is(fetches($x), 1);
359 is(stores($x), 0);
360
361 @foo = $x .. 8;
362 is(scalar @foo, 3);
363 is("@foo", "6 7 8");
364 is(fetches($x), 1);
365 is(stores($x), 0);
366
367 @foo = $x .. $x + 1;
368 is(scalar @foo, 2);
369 is("@foo", "6 7");
370 is(fetches($x), 2);
371 is(stores($x), 0);
372
373 @foo = ();
374 for (4 .. $x) {
375   push @foo, $_;
376 }
377 is(scalar @foo, 3);
378 is("@foo", "4 5 6");
379 is(fetches($x), 1);
380 is(stores($x), 0);
381
382 @foo = ();
383 for (reverse 4 .. $x) {
384   push @foo, $_;
385 }
386 is(scalar @foo, 3);
387 is("@foo", "6 5 4");
388 is(fetches($x), 1);
389 is(stores($x), 0);
390
391 is( ( join ' ', map { join '', map ++$_, ($x=1)..4 } 1..2 ), '2345 2345',
392     'modifiable variable num range' );
393 is( ( join ' ', map { join '', map ++$_, 1..4      } 1..2 ), '2345 3456',
394     'modifiable const num range' );  # Unresolved bug RT#3105
395 $s = ''; for (1..2) { for (1..4) { $s .= ++$_ } $s.=' ' if $_==1; }
396 is( $s, '2345 2345','modifiable num counting loop counter' );
397
398
399 is( ( join ' ', map { join '', map ++$_, ($x='a')..'d' } 1..2 ), 'bcde bcde',
400     'modifiable variable alpha range' );
401 is( ( join ' ', map { join '', map ++$_, 'a'..'d'      } 1..2 ), 'bcde cdef',
402     'modifiable const alpha range' );  # Unresolved bug RT#3105
403 $s = ''; for (1..2) { for ('a'..'d') { $s .= ++$_ } $s.=' ' if $_==1; }
404 is( $s, 'bcde bcde','modifiable alpha counting loop counter' );
405
406 # EOF