← Back to branch summary

~ubuntu-branches/ubuntu/saucy/python-scipy/saucy

« back to all changes in this revision

Viewing changes to scipy/weave/tests/test_slice_handler.py

  • Committer: Bazaar Package Importer
  • Author(s): Ondrej Certik
  • Date: 2008-06-16 22:58:01 UTC
  • mfrom: (2.1.24 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080616225801-irdhrpcwiocfbcmt
Tags: 0.6.0-12
http://bugs.debian.org/489149
* The description updated to match the current SciPy (Closes: #489149).
* Standards-Version bumped to 3.8.0 (no action needed)
* Build-Depends: netcdf-dev changed to libnetcdf-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
scipy/weave/tests/test_slice_handler.py
 
1
 
 
2
from numpy.testing import *
 
3
set_package_path()
 
4
from weave import slice_handler
 
5
from weave.slice_handler import indexed_array_pattern
 
6
from weave.ast_tools import *
 
7
restore_path()
 
8
 
 
9
def print_assert_equal(test_string,actual,desired):
 
10
    """this should probably be in scipy_test.testing
 
11
    """
 
12
    import pprint
 
13
    try:
 
14
        assert(actual == desired)
 
15
    except AssertionError:
 
16
        import cStringIO
 
17
        msg = cStringIO.StringIO()
 
18
        msg.write(test_string)
 
19
        msg.write(' failed\nACTUAL: \n')
 
20
        pprint.pprint(actual,msg)
 
21
        msg.write('DESIRED: \n')
 
22
        pprint.pprint(desired,msg)
 
23
        raise AssertionError, msg.getvalue()
 
24
 
 
25
class test_build_slice_atom(NumpyTestCase):
 
26
    def generic_test(self,slice_vars,desired):
 
27
        pos = slice_vars['pos']
 
28
        ast_list = slice_handler.build_slice_atom(slice_vars,pos)
 
29
        actual = ast_to_string(ast_list)
 
30
        print_assert_equal('',actual,desired)
 
31
    def check_exclusive_end(self):
 
32
        slice_vars = {'begin':'1', 'end':'2', 'step':'_stp',
 
33
                      'single_index':'_index','pos':0}
 
34
        desired = 'slice(1,2-1)'
 
35
        self.generic_test(slice_vars,desired)
 
36
 
 
37
class test_slice(NumpyTestCase):
 
38
 
 
39
    def generic_test(self,suite_string,desired):
 
40
        import parser
 
41
        ast_tuple = parser.suite(suite_string).totuple()
 
42
        found, data = find_first_pattern(ast_tuple,indexed_array_pattern)
 
43
        subscript = data['subscript_list'][1] #[0] is symbol, [1] is the supscript
 
44
        actual = slice_handler.slice_ast_to_dict(subscript)
 
45
        print_assert_equal(suite_string,actual,desired)
 
46
 
 
47
    def check_empty_2_slice(self):
 
48
        """match slice from a[:]"""
 
49
        test ="a[:]"
 
50
        desired = {'begin':'_beg', 'end':'_end', 'step':'_stp',
 
51
                   'single_index':'_index'}
 
52
        self.generic_test(test,desired)
 
53
    def check_begin_2_slice(self):
 
54
        """match slice from a[1:]"""
 
55
        test ="a[1:]"
 
56
        desired = {'begin':'1', 'end':'_end', 'step':'_stp',
 
57
                   'single_index':'_index'}
 
58
        self.generic_test(test,desired)
 
59
    def check_end_2_slice(self):
 
60
        """match slice from a[:2]"""
 
61
        test ="a[:2]"
 
62
        desired = {'begin':'_beg', 'end':'2', 'step':'_stp',
 
63
                   'single_index':'_index'}
 
64
        self.generic_test(test,desired)
 
65
    def check_begin_end_2_slice(self):
 
66
        """match slice from a[1:2]"""
 
67
        test ="a[1:2]"
 
68
        desired = {'begin':'1', 'end':'2', 'step':'_stp',
 
69
                   'single_index':'_index'}
 
70
        self.generic_test(test,desired)
 
71
    def check_empty_3_slice(self):
 
72
        """match slice from a[::]"""
 
73
        test ="a[::]"
 
74
        desired = {'begin':'_beg', 'end':'_end', 'step':'_stp',
 
75
                   'single_index':'_index'}
 
76
        self.generic_test(test,desired)
 
77
    def check_begin_3_slice(self):
 
78
        """match slice from a[1::]"""
 
79
        test ="a[1::]"
 
80
        desired = {'begin':'1', 'end':'_end', 'step':'_stp',
 
81
                   'single_index':'_index'}
 
82
        self.generic_test(test,desired)
 
83
    def check_end_3_slice(self):
 
84
        """match slice from a[:2:]"""
 
85
        test ="a[:2:]"
 
86
        desired = {'begin':'_beg', 'end':'2', 'step':'_stp',
 
87
                   'single_index':'_index'}
 
88
        self.generic_test(test,desired)
 
89
    def check_stp3_slice(self):
 
90
        """match slice from a[::3]"""
 
91
        test ="a[::3]"
 
92
        desired = {'begin':'_beg', 'end':'_end', 'step':'3',
 
93
                   'single_index':'_index'}
 
94
        self.generic_test(test,desired)
 
95
    def check_begin_end_3_slice(self):
 
96
        """match slice from a[1:2:]"""
 
97
        test ="a[1:2:]"
 
98
        desired = {'begin':'1', 'end':'2','step':'_stp',
 
99
                   'single_index':'_index'}
 
100
        self.generic_test(test,desired)
 
101
    def check_begin_step_3_slice(self):
 
102
        """match slice from a[1::3]"""
 
103
        test ="a[1::3]"
 
104
        desired = {'begin':'1', 'end':'_end','step':'3',
 
105
                   'single_index':'_index'}
 
106
        self.generic_test(test,desired)
 
107
    def check_end_step_3_slice(self):
 
108
        """match slice from a[:2:3]"""
 
109
        test ="a[:2:3]"
 
110
        desired = {'begin':'_beg', 'end':'2', 'step':'3',
 
111
                   'single_index':'_index'}
 
112
        self.generic_test(test,desired)
 
113
    def check_begin_end_stp3_slice(self):
 
114
        """match slice from a[1:2:3]"""
 
115
        test ="a[1:2:3]"
 
116
        desired = {'begin':'1', 'end':'2', 'step':'3','single_index':'_index'}
 
117
        self.generic_test(test,desired)
 
118
    def check_expr_3_slice(self):
 
119
        """match slice from a[:1+i+2:]"""
 
120
        test ="a[:1+i+2:]"
 
121
        desired = {'begin':'_beg', 'end':"1+i+2",'step':'_stp',
 
122
                   'single_index':'_index'}
 
123
        self.generic_test(test,desired)
 
124
    def check_single_index(self):
 
125
        """match slice from a[0]"""
 
126
        test ="a[0]"
 
127
        desired = {'begin':'_beg', 'end':"_end",'step':'_stp',
 
128
                   'single_index':'0'}
 
129
        self.generic_test(test,desired)
 
130
 
 
131
def replace_whitespace(in_str):
 
132
    import string
 
133
    out = string.replace(in_str," ","")
 
134
    out = string.replace(out,"\t","")
 
135
    out = string.replace(out,"\n","")
 
136
    return out
 
137
 
 
138
class test_transform_slices(NumpyTestCase):
 
139
    def generic_test(self,suite_string,desired):
 
140
        import parser
 
141
        ast_list = parser.suite(suite_string).tolist()
 
142
        slice_handler.transform_slices(ast_list)
 
143
        actual = ast_to_string(ast_list)
 
144
        # Remove white space from expressions so that equivelant
 
145
        # but differently formatted string will compare equally
 
146
        import string
 
147
        actual = replace_whitespace(actual)
 
148
        desired = replace_whitespace(desired)
 
149
        print_assert_equal(suite_string,actual,desired)
 
150
 
 
151
    def check_simple_expr(self):
 
152
        """transform a[:] to slice notation"""
 
153
        test ="a[:]"
 
154
        desired = 'a[slice(_beg,_end,_stp)]'
 
155
        self.generic_test(test,desired)
 
156
    def check_simple_expr(self):
 
157
        """transform a[:,:] = b[:,1:1+2:3] *(c[1-2+i:,:] - c[:,:])"""
 
158
        test ="a[:,:] = b[:,1:1+2:3] *(c[1-2+i:,:] - c[:,:])"
 
159
        desired = " a[slice(_beg,_end),slice(_beg,_end)] = "\
 
160
                                    " b[slice(_beg,_end), slice(1,1+2-1,3)] *"\
 
161
                                    " (c[slice(1-2+i,_end), slice(_beg,_end)] -"\
 
162
                                    "  c[slice(_beg,_end), slice(_beg,_end)])"
 
163
        self.generic_test(test,desired)
 
164
 
 
165
 
 
166
if __name__ == "__main__":
 
167
    NumpyTest('weave.slice_handler').run()