cython

1
# ticket: t425
2

3
cimport cython
4

5
@cython.test_assert_path_exists(
6
    "//ParallelAssignmentNode",
7
    "//ParallelAssignmentNode/SingleAssignmentNode",
8
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode/NameNode",
9
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode[@use_managed_ref=False]/NameNode",
10
    )
11
@cython.test_fail_if_path_exists(
12
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode[@use_managed_ref=True]",
13
    )
14
def swap(a,b):
15
    """
16
    >>> swap(1,2)
17
    (2, 1)
18
    """
19
    a,b = b,a
20
    return a,b
21

22

23
@cython.test_assert_path_exists(
24
    "//ParallelAssignmentNode",
25
    "//ParallelAssignmentNode/SingleAssignmentNode",
26
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode/NameNode",
27
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode[@use_managed_ref=False]/NameNode",
28
    )
29
@cython.test_fail_if_path_exists(
30
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode[@use_managed_ref=True]",
31
    )
32
def swap5(a,b,c,d,e):
33
    """
34
    >>> swap5(1,2,3,4,5)
35
    (5, 4, 3, 2, 1)
36
    """
37
    a,b,c,d,e = e,d,c,b,a
38
    return a,b,c,d,e
39

40

41
@cython.test_assert_path_exists(
42
    "//ParallelAssignmentNode",
43
    "//ParallelAssignmentNode/SingleAssignmentNode",
44
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode/NameNode",
45
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode[@use_managed_ref=False]/NameNode",
46
    )
47
@cython.test_fail_if_path_exists(
48
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode[@use_managed_ref=True]",
49
    )
50
cdef bint c_swap_cmp5(a, b, c, d, e):
51
    a,b,c,d,e = e,d,c,b,a
52
    return a > b > c > d > e
53

54
def swap_cmp5(a,b,c,d,e):
55
    """
56
    >>> swap_cmp5(1,2,3,4,5)
57
    True
58
    """
59
    return c_swap_cmp5(a,b,c,d,e)
60

61

62
@cython.test_assert_path_exists(
63
    "//ParallelAssignmentNode",
64
    "//ParallelAssignmentNode/SingleAssignmentNode",
65
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode/NameNode",
66
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode[@use_managed_ref=True]/NameNode",
67
    )
68
@cython.test_fail_if_path_exists(
69
    "//ParallelAssignmentNode/SingleAssignmentNode//CoerceToTempNode[@use_managed_ref=False]",
70
    )
71
def swap_py(a,b):
72
    """
73
    >>> swap_py(1,2)
74
    (1, 2)
75
    """
76
    a,a = b,a
77
    return a,b
78

79

80
cdef class A:
81
    cdef readonly object x
82
    cdef readonly object y
83
    def __init__(self, x, y):
84
        self.x, self.y = x, y
85

86
@cython.test_assert_path_exists(
87
    "//ParallelAssignmentNode",
88
    "//ParallelAssignmentNode/SingleAssignmentNode",
89
    "//ParallelAssignmentNode/SingleAssignmentNode/CoerceToTempNode",
90
    "//ParallelAssignmentNode/SingleAssignmentNode/CoerceToTempNode[@use_managed_ref=False]",
91
    "//ParallelAssignmentNode/SingleAssignmentNode//AttributeNode/NameNode",
92
    "//ParallelAssignmentNode/SingleAssignmentNode//AttributeNode[@use_managed_ref=False]/NameNode",
93
    )
94
@cython.test_fail_if_path_exists(
95
    "//ParallelAssignmentNode/SingleAssignmentNode/CoerceToTempNode[@use_managed_ref=True]",
96
    "//ParallelAssignmentNode/SingleAssignmentNode/AttributeNode[@use_managed_ref=True]",
97
    )
98
def swap_attr_values(A a, A b):
99
    """
100
    >>> a, b = A(1,2), A(3,4)
101
    >>> a.x, a.y, b.x, b.y
102
    (1, 2, 3, 4)
103
    >>> swap_attr_values(a,b)
104
    >>> a.x, a.y, b.x, b.y
105
    (3, 2, 1, 4)
106
    """
107
    a.x, a.y, b.x, b.y = a.y, b.x, b.y, a.x # shift by one
108
    a.x, a.y, b.x, b.y = b.x, b.y, a.x, a.y # shift by two
109
    a.x, a.y, b.x, b.y = b.y, b.x, a.y, a.x # reverse
110

111

112
cdef class B:
113
    cdef readonly A a1
114
    cdef readonly A a2
115
    def __init__(self, x1, y1, x2, y2):
116
        self.a1, self.a2 = A(x1, y1), A(x2, y2)
117

118
@cython.test_assert_path_exists(
119
    "//ParallelAssignmentNode",
120
    "//ParallelAssignmentNode/SingleAssignmentNode",
121
    "//ParallelAssignmentNode/SingleAssignmentNode/CoerceToTempNode",
122
    "//ParallelAssignmentNode/SingleAssignmentNode/CoerceToTempNode[@use_managed_ref=False]",
123
    "//ParallelAssignmentNode/SingleAssignmentNode//AttributeNode/NameNode",
124
    "//ParallelAssignmentNode/SingleAssignmentNode//AttributeNode[@use_managed_ref=False]/NameNode",
125
    )
126
@cython.test_fail_if_path_exists(
127
    "//ParallelAssignmentNode/SingleAssignmentNode/CoerceToTempNode[@use_managed_ref=True]",
128
    "//ParallelAssignmentNode/SingleAssignmentNode/AttributeNode[@use_managed_ref=True]",
129
    )
130
def swap_recursive_attr_values(B a, B b):
131
    """
132
    >>> a, b = B(1,2,3,4), B(5,6,7,8)
133
    >>> a.a1.x, a.a1.y, a.a2.x, a.a2.y
134
    (1, 2, 3, 4)
135
    >>> b.a1.x, b.a1.y, b.a2.x, b.a2.y
136
    (5, 6, 7, 8)
137
    >>> swap_recursive_attr_values(a,b)
138
    >>> a.a1.x, a.a1.y, a.a2.x, a.a2.y
139
    (2, 1, 4, 4)
140
    >>> b.a1.x, b.a1.y, b.a2.x, b.a2.y
141
    (6, 5, 8, 8)
142

143
    # compatibility test
144
    >>> class A:
145
    ...     def __init__(self, x, y):
146
    ...         self.x, self.y = x, y
147
    >>> class B:
148
    ...     def __init__(self, x1, y1, x2, y2):
149
    ...         self.a1, self.a2 = A(x1, y1), A(x2, y2)
150
    >>> a, b = B(1,2,3,4), B(5,6,7,8)
151
    >>> a.a1, a.a2 = a.a2, a.a1
152
    >>> b.a1, b.a2 = b.a2, b.a1
153
    >>> a.a1, a.a1.x, a.a2.y, a.a2, a.a1.y, a.a2.x = a.a2, a.a2.y, a.a1.x, a.a1, a.a2.x, a.a1.y
154
    >>> b.a1, b.a1.x, b.a2.y, b.a2, b.a1.y, b.a2.x = b.a2, b.a2.y, b.a1.x, b.a1, b.a2.x, b.a1.y
155
    >>> a.a1.x, a.a1.y, a.a2.x, a.a2.y
156
    (2, 1, 4, 4)
157
    >>> b.a1.x, b.a1.y, b.a2.x, b.a2.y
158
    (6, 5, 8, 8)
159
    """
160
    a.a1, a.a2 = a.a2, a.a1
161
    b.a1, b.a2 = b.a2, b.a1
162
    a.a1, a.a1.x, a.a2.y, a.a2, a.a1.y, a.a2.x = a.a2, a.a2.y, a.a1.x, a.a1, a.a2.x, a.a1.y
163
    b.a1, b.a1.x, b.a2.y, b.a2, b.a1.y, b.a2.x = b.a2, b.a2.y, b.a1.x, b.a1, b.a2.x, b.a1.y
164

165

166
@cython.test_assert_path_exists(
167
#    "//ParallelAssignmentNode",
168
#    "//ParallelAssignmentNode/SingleAssignmentNode",
169
#    "//ParallelAssignmentNode/SingleAssignmentNode//IndexNode",
170
#    "//ParallelAssignmentNode/SingleAssignmentNode//IndexNode[@use_managed_ref=False]",
171
    )
172
@cython.test_fail_if_path_exists(
173
#    "//ParallelAssignmentNode/SingleAssignmentNode//IndexNode[@use_managed_ref=True]",
174
    )
175
def swap_list_items(list a, int i, int j):
176
    """
177
    >>> l = [1,2,3,4]
178
    >>> swap_list_items(l, 1, 2)
179
    >>> l
180
    [1, 3, 2, 4]
181
    >>> swap_list_items(l, 3, 0)
182
    >>> l
183
    [4, 3, 2, 1]
184
    >>> swap_list_items(l, 0, 5)
185
    Traceback (most recent call last):
186
    IndexError: list index out of range
187
    >>> l
188
    [4, 3, 2, 1]
189
    """
190
    a[i], a[j] = a[j], a[i]
191

192

193
@cython.test_assert_path_exists(
194
    "//ParallelAssignmentNode",
195
    "//ParallelAssignmentNode/SingleAssignmentNode",
196
    "//ParallelAssignmentNode/SingleAssignmentNode//IndexNode",
197
    "//ParallelAssignmentNode/SingleAssignmentNode//IndexNode[@use_managed_ref=True]",
198
    )
199
@cython.test_fail_if_path_exists(
200
    "//ParallelAssignmentNode/SingleAssignmentNode//IndexNode[@use_managed_ref=False]",
201
    )
202
def swap_list_items_py1(list a, int i, int j):
203
    a[i], a[j] = a[j+1], a[i]
204

205

206
@cython.test_assert_path_exists(
207
    "//ParallelAssignmentNode",
208
    "//ParallelAssignmentNode/SingleAssignmentNode",
209
    "//ParallelAssignmentNode/SingleAssignmentNode//IndexNode",
210
    "//ParallelAssignmentNode/SingleAssignmentNode//IndexNode[@use_managed_ref=True]",
211
    )
212
@cython.test_fail_if_path_exists(
213
    "//ParallelAssignmentNode/SingleAssignmentNode//IndexNode[@use_managed_ref=False]",
214
    )
215
def swap_list_items_py2(list a, int i, int j):
216
    a[i], a[j] = a[i], a[i]
217