cython

1

2
cimport cython
3

4
module_level_tuple = (1,2,3)
5
second_module_level_tuple = (1,2,3)  # should be deduplicated to be the same as the first
6
string_module_level_tuple = ("1", "2")
7
string_module_level_tuple2 = ("1", "2")
8

9
def return_module_level_tuple():
10
    """
11
    >>> return_module_level_tuple()
12
    (1, 2, 3)
13
    """
14
    return module_level_tuple
15

16
def test_deduplicated_tuples():
17
    """
18
    >>> test_deduplicated_tuples()
19
    """
20
    assert (module_level_tuple is second_module_level_tuple)
21
    assert (module_level_tuple is (1,2,3))  # also deduplicated with a function tuple
22
    assert (string_module_level_tuple is string_module_level_tuple2)
23
    assert (string_module_level_tuple is ("1", "2"))
24

25
def func1(arg1, arg2):
26
    pass
27

28
def func2(arg1, arg2):
29
    pass
30

31
def test_deduplicated_args():
32
    """
33
    >>> test_deduplicated_args()
34
    """
35
    # This is a concern because in large modules *a lot* of similar code objects
36
    # are generated often with the same argument names. Therefore it's worth ensuring that
37
    # they are correctly deduplicated
38
    import sys
39
    check_identity_of_co_varnames = (
40
        not hasattr(sys, "pypy_version_info") and  # test doesn't work on PyPy (which is probably fair enough)
41
        sys.version_info < (3, 11)  # on Python 3.11 co_varnames returns a new, dynamically-calculated tuple
42
                                    # each time it is run
43
    )
44
    if check_identity_of_co_varnames:
45
        assert func1.__code__.co_varnames is func2.__code__.co_varnames
46

47
@cython.test_assert_path_exists("//TupleNode",
48
                                "//TupleNode[@is_literal = true]")
49
@cython.test_fail_if_path_exists("//TupleNode[@is_literal = false]")
50
def return_empty_tuple():
51
    """
52
    >>> return_empty_tuple()
53
    ()
54
    """
55
    return ()
56

57
@cython.test_assert_path_exists("//TupleNode",
58
                                "//TupleNode[@is_literal = true]")
59
@cython.test_fail_if_path_exists("//TupleNode[@is_literal = false]")
60
def return_constant_tuple1():
61
    """
62
    >>> return_constant_tuple1()
63
    (1,)
64
    """
65
    return (1,)
66

67
@cython.test_assert_path_exists("//TupleNode",
68
                                "//TupleNode[@is_literal = true]")
69
@cython.test_fail_if_path_exists("//TupleNode[@is_literal = false]")
70
def return_folded_tuple():
71
    """
72
    >>> return_folded_tuple()
73
    (1, 2, 3)
74
    """
75
    return (1, 1+1, 1+1+1)
76

77
@cython.test_assert_path_exists("//TupleNode",
78
                                "//TupleNode[@is_literal = true]")
79
@cython.test_fail_if_path_exists("//TupleNode[@is_literal = false]")
80
def return_nested_tuple():
81
    """
82
    >>> return_nested_tuple()
83
    (1, (2, 3), (3, (4, 5), (2, 3, 2, 3)))
84
    """
85
    return (1, (2, 3), (3, (4, 5), (2, 3) * 2))
86

87
@cython.test_assert_path_exists("//TupleNode",
88
                                "//TupleNode[@is_literal = true]")
89
@cython.test_fail_if_path_exists("//TupleNode[@is_literal = false]")
90
def constant_tuple1():
91
    """
92
    >>> constant_tuple1()
93
    (1,)
94
    """
95
    tuple1 = (1,)
96
    return tuple1
97

98
@cython.test_assert_path_exists("//TupleNode",
99
                                "//TupleNode[@is_literal = true]")
100
@cython.test_fail_if_path_exists("//TupleNode[@is_literal = false]")
101
def return_constant_tuple2():
102
    """
103
    >>> return_constant_tuple2()
104
    (1, 2)
105
    """
106
    return (1,2)
107

108

109
def return_multiplied_constant_tuple(n):
110
    """
111
    >>> tuples = return_multiplied_constant_tuple(2)
112
    >>> type(tuples) is tuple
113
    True
114
    >>> for t in tuples: print(t)
115
    ()
116
    (1, 2, 3)
117
    (1, 2, 3, 1, 2, 3)
118
    (1, 2, 3, 1, 2, 3, 1, 2, 3)
119
    (1, 2, 3, 1, 2, 3)
120
    (1, 2, 3, 1, 2, 3)
121
    ((1, 2, 3, 1, 2, 3), (1, 2, 3), (1, 2, 3, 1, 2, 3))
122
    """
123
    return (
124
        (1, 2, 3) * 0,
125
        (1, 2, 3) * 1,
126
        (1, 2, 3) * 2,
127
        (1, 2, 3) * 3,
128
        (1, 2, 3) * 2,
129
        (1, 2, 3) * n,
130
        ((1, 2, 3) * n, (1, 2, 3), (1, 2, 3) * n),
131
    )
132

133

134
@cython.test_assert_path_exists("//TupleNode",
135
                                "//TupleNode[@is_literal = true]")
136
@cython.test_fail_if_path_exists("//TupleNode[@is_literal = false]")
137
def return_constant_tuple_strings():
138
    """
139
    >>> return_constant_tuple_strings()
140
    ('tuple_1', 'bc', 'tuple_2')
141
    """
142
    return ('tuple_1', 'bc', 'tuple_2')
143

144

145
@cython.test_assert_path_exists("//TupleNode",
146
                                "//TupleNode[@is_literal = true]")
147
@cython.test_fail_if_path_exists("//TupleNode[@is_literal = false]")
148
def return_constant_tuples_string_types():
149
    """
150
    >>> a,b,c = return_constant_tuples_string_types()
151
    >>> a is b
152
    True
153
    >>> a is c
154
    False
155
    >>> b is c
156
    False
157
    """
158
    return ('a', 'bc'), (u'a', u'bc'), (b'a', b'bc')
159

160

161
@cython.test_assert_path_exists("//ReturnStatNode//TupleNode",
162
                                "//ReturnStatNode//TupleNode[@is_literal = false]")
163
@cython.test_fail_if_path_exists("//ReturnStatNode//TupleNode[@is_literal = true]")
164
def return_nonconstant_tuple():
165
    """
166
    >>> return_nonconstant_tuple()
167
    ('a', 1, 'd')
168
    """
169
    a = eval("1")
170
    return ('a', a, 'd')
171

172

173
def constant_types_comparing_equal():
174
    """
175
    >>> constant_types_comparing_equal()
176
    ((False, False), (0, 0), (0.0, 0.0), (0, False), (False, 0.0), (0, 0.0))
177
    """
178
    bool_tuple= (False, False)
179
    int_tuple = (0, 0)
180
    float_tuple = (0.0, 0.0)
181
    int_bool = (0, False)
182
    bool_float = (False, 0.0)
183
    int_float = (0, 0.0)
184

185
    assert bool_tuple is (False, False)
186
    assert int_tuple is (0, 0)
187
    assert bool_tuple == int_tuple
188
    assert bool_tuple is not int_tuple
189
    assert float_tuple is (0., 0.)
190
    assert float_tuple == int_tuple
191
    assert float_tuple is not int_tuple
192
    assert int_bool is (0, False)
193
    assert int_bool == bool_tuple
194
    assert int_bool is not bool_tuple
195
    assert int_bool is not int_tuple
196
    assert bool_float is (False, 0.)
197
    assert bool_float == bool_tuple
198
    assert bool_float is not bool_tuple
199
    assert bool_float is not float_tuple
200
    assert int_float is (0, 0.)
201
    assert int_float == int_tuple
202
    assert int_float is not int_tuple
203
    assert int_float is not float_tuple
204

205
    return bool_tuple, int_tuple, float_tuple, int_bool, bool_float, int_float
206