cython

1
# mode: run
2
# tag: forin, builtins, reversed, enumerate
3

4
cimport cython
5

6

7
def _reversed(it):
8
    return list(it)[::-1]
9

10
@cython.test_assert_path_exists('//ForInStatNode',
11
                                '//ForInStatNode/IteratorNode',
12
                                '//ForInStatNode/IteratorNode[@reversed = True]',
13
                                )
14
@cython.test_fail_if_path_exists('//ForInStatNode/IteratorNode//SimpleCallNode')
15
def reversed_list(list l):
16
    """
17
    >>> [ i for i in _reversed([1,2,3,4]) ]
18
    [4, 3, 2, 1]
19
    >>> reversed_list([1,2,3,4])
20
    [4, 3, 2, 1]
21
    >>> reversed_list([])
22
    []
23
    >>> reversed_list(None)
24
    Traceback (most recent call last):
25
    TypeError: 'NoneType' object is not iterable
26
    """
27
    result = []
28
    for item in reversed(l):
29
        result.append(item)
30
    return result
31

32
@cython.test_assert_path_exists('//ForInStatNode',
33
                                '//ForInStatNode/IteratorNode',
34
                                '//ForInStatNode/IteratorNode[@reversed = True]',
35
                                )
36
@cython.test_fail_if_path_exists('//ForInStatNode/IteratorNode//SimpleCallNode')
37
def reversed_tuple(tuple t):
38
    """
39
    >>> [ i for i in _reversed((1,2,3,4)) ]
40
    [4, 3, 2, 1]
41
    >>> reversed_tuple((1,2,3,4))
42
    [4, 3, 2, 1]
43
    >>> reversed_tuple(())
44
    []
45
    >>> reversed_tuple(None)
46
    Traceback (most recent call last):
47
    TypeError: 'NoneType' object is not iterable
48
    """
49
    result = []
50
    for item in reversed(t):
51
        result.append(item)
52
    return result
53

54
@cython.test_assert_path_exists('//ForInStatNode',
55
                                '//ForInStatNode/IteratorNode',
56
                                '//ForInStatNode/IteratorNode[@reversed = True]',
57
                                )
58
@cython.test_fail_if_path_exists('//ForInStatNode/IteratorNode//SimpleCallNode')
59
def enumerate_reversed_list(list l):
60
    """
61
    >>> list(enumerate(_reversed([1,2,3])))
62
    [(0, 3), (1, 2), (2, 1)]
63
    >>> enumerate_reversed_list([1,2,3])
64
    [(0, 3), (1, 2), (2, 1)]
65
    >>> enumerate_reversed_list([])
66
    []
67
    >>> enumerate_reversed_list(None)
68
    Traceback (most recent call last):
69
    TypeError: 'NoneType' object is not iterable
70
    """
71
    result = []
72
    cdef Py_ssize_t i
73
    for i, item in enumerate(reversed(l)):
74
        result.append((i, item))
75
    return result
76

77
@cython.test_assert_path_exists('//ForFromStatNode')
78
def reversed_range(int N):
79
    """
80
    >>> [ i for i in _reversed(range(5)) ]
81
    [4, 3, 2, 1, 0]
82
    >>> reversed_range(5)
83
    ([4, 3, 2, 1, 0], 0)
84

85
    >>> [ i for i in _reversed(range(0)) ]
86
    []
87
    >>> reversed_range(0)
88
    ([], 99)
89
    """
90
    cdef int i = 99
91
    result = []
92
    for i in reversed(range(N)):
93
        result.append(i)
94
    return result, i
95

96
@cython.test_assert_path_exists('//ForFromStatNode')
97
def reversed_range_step_pos(int a, int b):
98
    """
99
    >>> [ i for i in _reversed(range(0, 5, 1)) ]
100
    [4, 3, 2, 1, 0]
101
    >>> reversed_range_step_pos(0, 5)
102
    ([4, 3, 2, 1, 0], 0)
103

104
    >>> [ i for i in _reversed(range(5, 0, 1)) ]
105
    []
106
    >>> reversed_range_step_pos(5, 0)
107
    ([], 99)
108
    """
109
    cdef int i = 99
110
    result = []
111
    for i in reversed(range(a, b, 1)):
112
        result.append(i)
113
    return result, i
114

115
@cython.test_assert_path_exists('//ForFromStatNode')
116
def reversed_range_step_neg(int a, int b):
117
    """
118
    >>> [ i for i in _reversed(range(5, -1, -1)) ]
119
    [0, 1, 2, 3, 4, 5]
120
    >>> reversed_range_step_neg(5, -1)
121
    ([0, 1, 2, 3, 4, 5], 5)
122

123
    >>> [ i for i in _reversed(range(0, 5, -1)) ]
124
    []
125
    >>> reversed_range_step_neg(0, 5)
126
    ([], 99)
127
    """
128
    cdef int i = 99
129
    result = []
130
    for i in reversed(range(a, b, -1)):
131
        result.append(i)
132
    return result, i
133

134
@cython.test_assert_path_exists('//ForFromStatNode')
135
@cython.test_fail_if_path_exists('//ForInStatNode')
136
def reversed_range_step3(int a, int b):
137
    """
138
    >>> [ i for i in _reversed(range(-5, 0, 3)) ]
139
    [-2, -5]
140
    >>> reversed_range_step3(-5, 0)
141
    ([-2, -5], -5)
142

143
    >>> [ i for i in _reversed(range(0, 5, 3)) ]
144
    [3, 0]
145
    >>> reversed_range_step3(0, 5)
146
    ([3, 0], 0)
147

148
    >>> [ i for i in _reversed(range(5, 0, 3)) ]
149
    []
150
    >>> reversed_range_step3(5, 0)
151
    ([], 99)
152

153
    >>> [ i for i in _reversed(range(1, 1, 3)) ]
154
    []
155
    >>> reversed_range_step3(1, 1)
156
    ([], 99)
157
    """
158
    cdef int i = 99
159
    result = []
160
    for i in reversed(range(a, b, 3)):
161
        result.append(i)
162
    return result, i
163

164
@cython.test_assert_path_exists('//ForFromStatNode')
165
@cython.test_fail_if_path_exists('//ForInStatNode')
166
def reversed_range_step3_expr(int a, int b):
167
    """
168
    >>> [ i for i in _reversed(range(0, 5, 3)) ]
169
    [3, 0]
170
    >>> reversed_range_step3_expr(0, 5)
171
    ([3, 0], 0)
172
    """
173
    cdef int i = 99, c = 100
174
    result = []
175
    for i in reversed(range(c-c + a + c-c, c-c + b + c-c, 3)):
176
        result.append(i)
177
    return result, i
178

179
@cython.test_assert_path_exists('//ForFromStatNode')
180
@cython.test_fail_if_path_exists('//ForInStatNode')
181
def reversed_range_step3_neg(int a, int b):
182
    """
183
    >>> [ i for i in _reversed(range(0, -5, -3)) ]
184
    [-3, 0]
185
    >>> reversed_range_step3_neg(0, -5)
186
    ([-3, 0], 0)
187

188
    >>> [ i for i in _reversed(range(5, 0, -3)) ]
189
    [2, 5]
190
    >>> reversed_range_step3_neg(5, 0)
191
    ([2, 5], 5)
192

193
    >>> [ i for i in _reversed(range(0, 5, -3)) ]
194
    []
195
    >>> reversed_range_step3_neg(0, 5)
196
    ([], 99)
197

198
    >>> [ i for i in _reversed(range(1, 1, -3)) ]
199
    []
200
    >>> reversed_range_step3_neg(1, 1)
201
    ([], 99)
202
    """
203
    cdef int i = 99
204
    result = []
205
    for i in reversed(range(a, b, -3)):
206
        result.append(i)
207
    return result, i
208

209
@cython.test_assert_path_exists('//ForFromStatNode')
210
@cython.test_fail_if_path_exists('//ForInStatNode')
211
def reversed_range_step3_neg_expr(int a, int b):
212
    """
213
    >>> [ i for i in _reversed(range(5, 0, -3)) ]
214
    [2, 5]
215
    >>> reversed_range_step3_neg_expr(5, 0)
216
    ([2, 5], 5)
217
    """
218
    cdef int i = 99, c = 100
219
    result = []
220
    for i in reversed(range(c-c + a + c-c, c-c + b + c-c, -3)):
221
        result.append(i)
222
    return result, i
223

224
def reversed_range_step3_py_args(a, b):
225
    """
226
    >>> [ i for i in _reversed(range(-5, 0, 3)) ]
227
    [-2, -5]
228
    >>> reversed_range_step3_py_args(-5, 0)
229
    ([-2, -5], -5)
230

231
    >>> [ i for i in _reversed(range(0, 5, 3)) ]
232
    [3, 0]
233
    >>> reversed_range_step3_py_args(0, 5)
234
    ([3, 0], 0)
235

236
    >>> [ i for i in _reversed(range(5, 0, 3)) ]
237
    []
238
    >>> reversed_range_step3_py_args(5, 0)
239
    ([], 99)
240

241
    >>> [ i for i in _reversed(range(1, 1, 3)) ]
242
    []
243
    >>> reversed_range_step3_py_args(1, 1)
244
    ([], 99)
245

246
    >>> reversed_range_step3_py_args(set(), 1) # doctest: +ELLIPSIS
247
    Traceback (most recent call last):
248
    TypeError: ...integer...
249

250
    >>> reversed_range_step3_py_args(1, set()) # doctest: +ELLIPSIS
251
    Traceback (most recent call last):
252
    TypeError: ...integer...
253
    """
254
    i = 99
255
    result = []
256
    for i in reversed(range(a, b, 3)):
257
        result.append(i)
258
    return result, i
259

260
def reversed_range_step3_neg_py_args(a, b):
261
    """
262
    >>> [ i for i in _reversed(range(0, -5, -3)) ]
263
    [-3, 0]
264
    >>> reversed_range_step3_neg_py_args(0, -5)
265
    ([-3, 0], 0)
266

267
    >>> [ i for i in _reversed(range(5, 0, -3)) ]
268
    [2, 5]
269
    >>> reversed_range_step3_neg_py_args(5, 0)
270
    ([2, 5], 5)
271

272
    >>> [ i for i in _reversed(range(0, 5, -3)) ]
273
    []
274
    >>> reversed_range_step3_neg_py_args(0, 5)
275
    ([], 99)
276

277
    >>> [ i for i in _reversed(range(1, 1, -3)) ]
278
    []
279
    >>> reversed_range_step3_neg_py_args(1, 1)
280
    ([], 99)
281

282
    >>> reversed_range_step3_neg_py_args(set(), 1) # doctest: +ELLIPSIS
283
    Traceback (most recent call last):
284
    TypeError: ...integer...
285

286
    >>> reversed_range_step3_neg_py_args(1, set()) # doctest: +ELLIPSIS
287
    Traceback (most recent call last):
288
    TypeError: ...integer...
289
    """
290
    i = 99
291
    result = []
292
    for i in reversed(range(a, b, -3)):
293
        result.append(i)
294
    return result, i
295

296
def reversed_range_step3_py_obj_left(a, int b):
297
    """
298
    >>> reversed_range_step3_py_obj_left(set(), 0)  # doctest: +ELLIPSIS
299
    Traceback (most recent call last):
300
    TypeError: ...int...
301
    """
302
    cdef long i
303
    result = []
304
    for i in reversed(range(a, b, 3)):
305
        result.append(i)
306

307
def reversed_range_step3_py_obj_right(int a, b):
308
    """
309
    >>> reversed_range_step3_py_obj_right(0, set())  # doctest: +ELLIPSIS
310
    Traceback (most recent call last):
311
    TypeError: ...int...
312
    """
313
    cdef long i
314
    result = []
315
    for i in reversed(range(a, b, 3)):
316
        result.append(i)
317

318
def reversed_range_step3_neg_py_obj_left(a, int b):
319
    """
320
    >>> reversed_range_step3_neg_py_obj_left(set(), 0)  # doctest: +ELLIPSIS
321
    Traceback (most recent call last):
322
    TypeError: ...int...
323
    """
324
    cdef long i
325
    result = []
326
    for i in reversed(range(a, b, -3)):
327
        result.append(i)
328

329
def reversed_range_step3_neg_py_obj_right(int a, b):
330
    """
331
    >>> reversed_range_step3_py_obj_right(0, set())  # doctest: +ELLIPSIS
332
    Traceback (most recent call last):
333
    TypeError: ...int...
334
    """
335
    cdef long i
336
    result = []
337
    for i in reversed(range(a, b, -3)):
338
        result.append(i)
339

340
@cython.test_fail_if_path_exists('//ForInStatNode')
341
def reversed_range_constant():
342
    """
343
    >>> [ i for i in _reversed(range(-12, -2, 4)) ]
344
    [-4, -8, -12]
345
    >>> reversed_range_constant()
346
    ([-4, -8, -12], -12)
347
    """
348
    cdef int i = 99
349
    result = []
350
    for i in reversed(range(1, 1, 4)):
351
        result.append(i)
352
    assert result == list(reversed(range(1, 1, 4))), result
353
    assert i == 99
354

355
    for i in reversed(range(1, 1, 1)):
356
        result.append(i)
357
    assert result == list(reversed(range(1, 1, 1))), result
358

359
    result = []
360
    for i in reversed(range(0, 1, 4)):
361
        result.append(i)
362
    assert result == list(reversed(range(0, 1, 4))), result
363

364
    result = []
365
    for i in reversed(range(0, 1, 1)):
366
        result.append(i)
367
    assert result == list(reversed(range(0, 1, 1))), result
368

369
    result = []
370
    for i in reversed(range(1, 8, 4)):
371
        result.append(i)
372
    assert result == list(reversed(range(1, 8, 4))), result
373

374
    result = []
375
    for i in reversed(range(1, 8, 1)):
376
        result.append(i)
377
    assert result == list(reversed(range(1, 8, 1))), result
378

379
    result = []
380
    for i in reversed(range(1, 9, 4)):
381
        result.append(i)
382
    assert result == list(reversed(range(1, 9, 4))), result
383

384
    result = []
385
    for i in reversed(range(1, 10, 4)):
386
        result.append(i)
387
    assert result == list(reversed(range(1, 10, 4))), result
388

389
    result = []
390
    for i in reversed(range(1, 11, 4)):
391
        result.append(i)
392
    assert result == list(reversed(range(1, 11, 4))), result
393

394
    result = []
395
    for i in reversed(range(1, 12, 4)):
396
        result.append(i)
397
    assert result == list(reversed(range(1, 12, 4))), result
398

399
    result = []
400
    for i in reversed(range(0, 8, 4)):
401
        result.append(i)
402
    assert result == list(reversed(range(0, 8, 4))), result
403

404
    result = []
405
    for i in reversed(range(0, 9, 4)):
406
        result.append(i)
407
    assert result == list(reversed(range(0, 9, 4))), result
408

409
    result = []
410
    for i in reversed(range(0, 10, 4)):
411
        result.append(i)
412
    assert result == list(reversed(range(0, 10, 4))), result
413

414
    result = []
415
    for i in reversed(range(0, 11, 4)):
416
        result.append(i)
417
    assert result == list(reversed(range(0, 11, 4))), result
418

419
    result = []
420
    for i in reversed(range(0, 12, 4)):
421
        result.append(i)
422
    assert result == list(reversed(range(0, 12, 4))), result
423

424
    i = 99
425
    result = []
426
    for i in reversed(range(-12, -2, 4)):
427
        result.append(i)
428
    assert result == list(reversed(range(-12, -2, 4))), result
429
    return result, i
430

431
@cython.test_assert_path_exists('//ForFromStatNode')
432
@cython.test_fail_if_path_exists('//ForInStatNode')
433
def reversed_range_constant_neg():
434
    """
435
    >>> [ i for i in _reversed(range(-2, -12, -4)) ]
436
    [-10, -6, -2]
437
    >>> reversed_range_constant_neg()
438
    """
439
    cdef int i = 99
440
    result = []
441
    for i in reversed(range(1, 1, -4)):
442
        result.append(i)
443
    assert result == list(reversed(range(1, 1, -4))), result
444
    assert i == 99
445

446
    result = []
447
    for i in reversed(range(1, 1, -1)):
448
        result.append(i)
449
    assert result == list(reversed(range(1, 1, -1))), result
450

451
    result = []
452
    for i in reversed(range(1, 0, -4)):
453
        result.append(i)
454
    assert result == list(reversed(range(1, 0, -4))), result
455

456
    result = []
457
    for i in reversed(range(1, 0, -1)):
458
        result.append(i)
459
    assert result == list(reversed(range(1, 0, -1))), result
460

461
    result = []
462
    for i in reversed(range(8, 1, -4)):
463
        result.append(i)
464
    assert result == list(reversed(range(8, 1, -4))), result
465

466
    result = []
467
    for i in reversed(range(8, 1, -1)):
468
        result.append(i)
469
    assert result == list(reversed(range(8, 1, -1))), result
470

471
    result = []
472
    for i in reversed(range(9, 1, -4)):
473
        result.append(i)
474
    assert result == list(reversed(range(9, 1, -4))), result
475

476
    result = []
477
    for i in reversed(range(9, 1, -1)):
478
        result.append(i)
479
    assert result == list(reversed(range(9, 1, -1))), result
480

481
    result = []
482
    for i in reversed(range(10, 1, -4)):
483
        result.append(i)
484
    assert result == list(reversed(range(10, 1, -4))), result
485

486
    result = []
487
    for i in reversed(range(11, 1, -4)):
488
        result.append(i)
489
    assert result == list(reversed(range(11, 1, -4))), result
490

491
    result = []
492
    for i in reversed(range(11, 1, -1)):
493
        result.append(i)
494
    assert result == list(reversed(range(11, 1, -1))), result
495

496
    result = []
497
    for i in reversed(range(12, 1, -4)):
498
        result.append(i)
499
    assert result == list(reversed(range(12, 1, -4))), result
500

501
    result = []
502
    for i in reversed(range(12, 1, -1)):
503
        result.append(i)
504
    assert result == list(reversed(range(12, 1, -1))), result
505

506
    result = []
507
    for i in reversed(range(8, 0, -4)):
508
        result.append(i)
509
    assert result == list(reversed(range(8, 0, -4))), result
510

511
    result = []
512
    for i in reversed(range(8, 0, -1)):
513
        result.append(i)
514
    assert result == list(reversed(range(8, 0, -1))), result
515

516
    result = []
517
    for i in reversed(range(9, 0, -4)):
518
        result.append(i)
519
    assert result == list(reversed(range(9, 0, -4))), result
520

521
    result = []
522
    for i in reversed(range(9, 0, -1)):
523
        result.append(i)
524
    assert result == list(reversed(range(9, 0, -1))), result
525

526
    result = []
527
    for i in reversed(range(10, 0, -4)):
528
        result.append(i)
529
    assert result == list(reversed(range(10, 0, -4))), result
530

531
    result = []
532
    for i in reversed(range(10, 0, -1)):
533
        result.append(i)
534
    assert result == list(reversed(range(10, 0, -1))), result
535

536
    result = []
537
    for i in reversed(range(11, 0, -4)):
538
        result.append(i)
539
    assert result == list(reversed(range(11, 0, -4))), result
540

541
    result = []
542
    for i in reversed(range(11, 0, -1)):
543
        result.append(i)
544
    assert result == list(reversed(range(11, 0, -1))), result
545

546
    result = []
547
    for i in reversed(range(12, 0, -4)):
548
        result.append(i)
549
    assert result == list(reversed(range(12, 0, -4))), result
550

551
    result = []
552
    for i in reversed(range(12, 0, -1)):
553
        result.append(i)
554
    assert result == list(reversed(range(12, 0, -1))), result
555

556
    result = []
557
    for i in reversed(range(-2, -12, -4)):
558
        result.append(i)
559
    assert result == list(reversed(range(-2, -12, -4))), result
560

561
    result = []
562
    for i in reversed(range(-2, -12, -1)):
563
        result.append(i)
564
    assert result == list(reversed(range(-2, -12, -1))), result
565

566
unicode_string = u"abcDEF"
567

568
@cython.test_assert_path_exists('//ForFromStatNode')
569
def reversed_unicode(unicode u):
570
    """
571
    >>> print(''.join(_reversed(unicode_string)))
572
    FEDcba
573
    >>> print(''.join(reversed_unicode(unicode_string)))
574
    FEDcba
575
    """
576
    result = []
577
    for c in reversed(u):
578
        result.append(c)
579
    return result
580

581
@cython.test_assert_path_exists('//ForFromStatNode')
582
def reversed_unicode_slice(unicode u):
583
    """
584
    >>> print(''.join(_reversed(unicode_string[1:-2])))
585
    Dcb
586
    >>> print(''.join(reversed_unicode_slice(unicode_string)))
587
    Dcb
588
    """
589
    result = []
590
    for c in reversed(u[1:-2]):
591
        result.append(c)
592
    return result
593

594
@cython.test_assert_path_exists('//ForFromStatNode')
595
def reversed_unicode_slice_neg_step(unicode u):
596
    """
597
    >>> print(''.join(_reversed(unicode_string[-2:1:-1])))
598
    cDE
599
    >>> print(''.join(reversed_unicode_slice_neg_step(unicode_string)))
600
    cDE
601
    """
602
    result = []
603
    for c in reversed(u[-2:1:-1]):
604
        result.append(c)
605
    return result
606

607
@cython.test_assert_path_exists('//ForFromStatNode')
608
def reversed_unicode_slice_pos_step(unicode u):
609
    """
610
    >>> print(''.join(_reversed(unicode_string[1:-2:1])))
611
    Dcb
612
    >>> print(''.join(reversed_unicode_slice_pos_step(unicode_string)))
613
    Dcb
614
    """
615
    result = []
616
    for c in reversed(u[1:-2:1]):
617
        result.append(c)
618
    return result
619

620
@cython.test_assert_path_exists('//ForFromStatNode')
621
def reversed_unicode_slice_start_pos_step(unicode u):
622
    """
623
    >>> print(''.join(_reversed(unicode_string[2::1])))
624
    FEDc
625
    >>> print(''.join(reversed_unicode_slice_start_pos_step(unicode_string)))
626
    FEDc
627
    """
628
    result = []
629
    for c in reversed(u[2::1]):
630
        result.append(c)
631
    return result
632

633
@cython.test_assert_path_exists('//ForFromStatNode')
634
def reversed_unicode_slice_start_neg_step(unicode u):
635
    """
636
    >>> print(''.join(_reversed(unicode_string[3::-1])))
637
    abcD
638
    >>> print(''.join(reversed_unicode_slice_start_neg_step(unicode_string)))
639
    abcD
640
    """
641
    result = []
642
    for c in reversed(u[3::-1]):
643
        result.append(c)
644
    return result
645

646
@cython.test_assert_path_exists('//ForFromStatNode')
647
def reversed_unicode_slice_end_pos_step(unicode u):
648
    """
649
    >>> print(''.join(_reversed(unicode_string[:-2:1])))
650
    Dcba
651
    >>> print(''.join(reversed_unicode_slice_end_pos_step(unicode_string)))
652
    Dcba
653
    """
654
    result = []
655
    for c in reversed(u[:-2:1]):
656
        result.append(c)
657
    return result
658

659
@cython.test_assert_path_exists('//ForFromStatNode')
660
def reversed_unicode_slice_end_neg_step(unicode u):
661
    """
662
    >>> print(''.join(_reversed(unicode_string[:-3:-1])))
663
    EF
664
    >>> print(''.join(reversed_unicode_slice_end_neg_step(unicode_string)))
665
    EF
666
    """
667
    result = []
668
    for c in reversed(u[:-3:-1]):
669
        result.append(c)
670
    return result
671

672
@cython.test_assert_path_exists('//ForFromStatNode')
673
def reversed_unicode_slice_neg_step_only(unicode u):
674
    """
675
    >>> print(''.join(_reversed(unicode_string[::-1])))
676
    abcDEF
677
    >>> print(''.join(reversed_unicode_slice_neg_step_only(unicode_string)))
678
    abcDEF
679
    """
680
    result = []
681
    for c in reversed(u[::-1]):
682
        result.append(c)
683
    return result
684

685
@cython.test_assert_path_exists('//ForFromStatNode')
686
def reversed_unicode_slice_pos_step_only(unicode u):
687
    """
688
    >>> print(''.join(_reversed(unicode_string[::1])))
689
    FEDcba
690
    >>> print(''.join(reversed_unicode_slice_pos_step_only(unicode_string)))
691
    FEDcba
692
    """
693
    result = []
694
    for c in reversed(u[::1]):
695
        result.append(c)
696
    return result
697

698
bytes_string = b'abcDEF'
699
join_bytes = b''.join
700

701
@cython.test_assert_path_exists('//ForFromStatNode')
702
def reversed_bytes(bytes s):
703
    """
704
    >>> list(_reversed(bytes_string))
705
    [70, 69, 68, 99, 98, 97]
706
    >>> reversed_bytes(bytes_string)
707
    [70, 69, 68, 99, 98, 97]
708
    """
709
    cdef char c
710
    result = []
711
    for c in reversed(s):
712
        result.append(c)
713
    return result
714

715
@cython.test_assert_path_exists('//ForFromStatNode')
716
def reversed_bytes_slice(bytes s):
717
    """
718
    >>> list(_reversed(bytes_string[1:-2]))
719
    [68, 99, 98]
720
    >>> reversed_bytes_slice(bytes_string)
721
    [68, 99, 98]
722
    """
723
    cdef char c
724
    result = []
725
    for c in reversed(s[1:-2]):
726
        result.append(c)
727
    return result
728

729
@cython.test_assert_path_exists('//ForFromStatNode')
730
def reversed_bytes_slice_step(bytes s):
731
    """
732
    >>> list(_reversed(bytes_string[-2:1:-1]))
733
    [99, 68, 69]
734
    >>> reversed_bytes_slice_step(bytes_string)
735
    [99, 68, 69]
736
    """
737
    cdef char c
738
    result = []
739
    for c in reversed(s[-2:1:-1]):
740
        result.append(c)
741
    return result
742

743
@cython.test_assert_path_exists('//ForFromStatNode')
744
def reversed_bytes_slice_step_only(bytes s):
745
    """
746
    >>> list(_reversed(bytes_string[::-1]))
747
    [97, 98, 99, 68, 69, 70]
748
    >>> reversed_bytes_slice_step_only(bytes_string)
749
    [97, 98, 99, 68, 69, 70]
750
    """
751
    cdef char c
752
    result = []
753
    for c in reversed(s[::-1]):
754
        result.append(c)
755
    return result
756

757

758
@cython.test_assert_path_exists('//ForFromStatNode')
759
def reversed_unsigned(int a, int b):
760
    """
761
    >>> reversed_unsigned(0, 5)
762
    [4, 3, 2, 1, 0]
763
    >>> reversed_unsigned(1, 5)
764
    [4, 3, 2, 1]
765
    >>> reversed_unsigned(1, 1)
766
    []
767
    """
768
    cdef unsigned int i
769
    return [i for i in reversed(range(a, b))]
770

771
@cython.test_assert_path_exists('//ForFromStatNode')
772
def reversed_unsigned_by_3(int a, int b):
773
    """
774
    >>> reversed_unsigned_by_3(0, 5)
775
    [3, 0]
776
    >>> reversed_unsigned_by_3(0, 7)
777
    [6, 3, 0]
778
    """
779
    cdef unsigned int i
780
    return [i for i in reversed(range(a, b, 3))]
781

782
@cython.test_assert_path_exists('//ForFromStatNode')
783
def range_unsigned_by_neg_3(int a, int b):
784
    """
785
    >>> range_unsigned_by_neg_3(-1, 6)
786
    [6, 3, 0]
787
    >>> range_unsigned_by_neg_3(0, 7)
788
    [7, 4, 1]
789
    """
790
    cdef unsigned int i
791
    return [i for i in range(b, a, -3)]
792