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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
from __future__ import absolute_import, print_function
import parser
from numpy.testing import TestCase, assert_equal, run_module_suite
from scipy.weave import slice_handler
from scipy.weave.slice_handler import indexed_array_pattern
from scipy.weave.ast_tools import ast_to_string, find_first_pattern
from weave_test_utils import remove_whitespace
class TestBuildSliceAtom(TestCase):
def generic_check(self,slice_vars,desired):
pos = slice_vars['pos']
ast_list = slice_handler.build_slice_atom(slice_vars,pos)
actual = ast_to_string(ast_list)
assert_equal(actual,desired)
def test_exclusive_end(self):
slice_vars = {'begin':'1', 'end':'2', 'step':'_stp',
'single_index':'_index','pos':0}
desired = 'slice(1,2-1)'
self.generic_check(slice_vars,desired)
class TestSlice(TestCase):
def generic_check(self,suite_string,desired):
ast_tuple = parser.suite(suite_string).totuple()
found, data = find_first_pattern(ast_tuple,indexed_array_pattern)
subscript = data['subscript_list'][1] # [0] is symbol, [1] is the subscript
actual = slice_handler.slice_ast_to_dict(subscript)
assert_equal(actual,desired,suite_string)
def test_empty_2_slice(self):
# match slice from a[:]
test = "a[:]"
desired = {'begin':'_beg', 'end':'_end', 'step':'_stp',
'single_index':'_index'}
self.generic_check(test,desired)
def test_begin_2_slice(self):
# match slice from a[1:]
test = "a[1:]"
desired = {'begin':'1', 'end':'_end', 'step':'_stp',
'single_index':'_index'}
self.generic_check(test,desired)
def test_end_2_slice(self):
# match slice from a[:2]
test = "a[:2]"
desired = {'begin':'_beg', 'end':'2', 'step':'_stp',
'single_index':'_index'}
self.generic_check(test,desired)
def test_begin_end_2_slice(self):
# match slice from a[1:2]
test = "a[1:2]"
desired = {'begin':'1', 'end':'2', 'step':'_stp',
'single_index':'_index'}
self.generic_check(test,desired)
def test_empty_3_slice(self):
# match slice from a[::]
test = "a[::]"
desired = {'begin':'_beg', 'end':'_end', 'step':'_stp',
'single_index':'_index'}
self.generic_check(test,desired)
def test_begin_3_slice(self):
# match slice from a[1::]
test = "a[1::]"
desired = {'begin':'1', 'end':'_end', 'step':'_stp',
'single_index':'_index'}
self.generic_check(test,desired)
def test_end_3_slice(self):
# match slice from a[:2:]
test = "a[:2:]"
desired = {'begin':'_beg', 'end':'2', 'step':'_stp',
'single_index':'_index'}
self.generic_check(test,desired)
def test_stp3_slice(self):
# match slice from a[::3]
test = "a[::3]"
desired = {'begin':'_beg', 'end':'_end', 'step':'3',
'single_index':'_index'}
self.generic_check(test,desired)
def test_begin_end_3_slice(self):
# match slice from a[1:2:]
test = "a[1:2:]"
desired = {'begin':'1', 'end':'2','step':'_stp',
'single_index':'_index'}
self.generic_check(test,desired)
def test_begin_step_3_slice(self):
# match slice from a[1::3]
test = "a[1::3]"
desired = {'begin':'1', 'end':'_end','step':'3',
'single_index':'_index'}
self.generic_check(test,desired)
def test_end_step_3_slice(self):
# match slice from a[:2:3]
test = "a[:2:3]"
desired = {'begin':'_beg', 'end':'2', 'step':'3',
'single_index':'_index'}
self.generic_check(test,desired)
def test_begin_end_stp3_slice(self):
# match slice from a[1:2:3]
test = "a[1:2:3]"
desired = {'begin':'1', 'end':'2', 'step':'3','single_index':'_index'}
self.generic_check(test,desired)
def test_expr_3_slice(self):
# match slice from a[:1+i+2:]
test = "a[:1+i+2:]"
desired = {'begin':'_beg', 'end':"1+i+2",'step':'_stp',
'single_index':'_index'}
self.generic_check(test,desired)
def test_single_index(self):
# match slice from a[0]
test = "a[0]"
desired = {'begin':'_beg', 'end':"_end",'step':'_stp',
'single_index':'0'}
self.generic_check(test,desired)
class TestTransformSlices(TestCase):
def generic_check(self,suite_string,desired):
ast_list = parser.suite(suite_string).tolist()
slice_handler.transform_slices(ast_list)
actual = ast_to_string(ast_list)
# Remove white space from expressions so that equivalent
# but differently formatted string will compare equally
actual = remove_whitespace(actual)
desired = remove_whitespace(desired)
assert_equal(actual,desired,suite_string)
def test_simple_expr1(self):
# transform a[:] to slice notation
test = "a[:]"
desired = 'a[slice(_beg,_end)]'
self.generic_check(test,desired)
def test_simple_expr2(self):
test = "a[:,:] = b[:,1:1+2:3] *(c[1-2+i:,:] - c[:,:])"
desired = " a[slice(_beg,_end),slice(_beg,_end)] = "\
" b[slice(_beg,_end), slice(1,1+2-1,3)] *"\
" (c[slice(1-2+i,_end), slice(_beg,_end)] -"\
" c[slice(_beg,_end), slice(_beg,_end)])"
self.generic_check(test,desired)
if __name__ == "__main__":
run_module_suite()
|
