source: trunk/test/sucasa/unit/test_parser.py @ 1768

Last change on this file since 1768 was 1768, checked in by wehart, 11 years ago

Rework of Coopr to use the new PyUtilib? package decomposition.

NOTE: to use Coopr with this update, we need to work with a new version of coopr_install.

File size: 9.1 KB
Line 
1#
2# Unit Tests for ampl_info
3#
4
5
6import os
7import sys
8from os.path import abspath, dirname
9sys.path.insert(0, dirname(dirname(abspath(__file__)))+os.sep+".."+os.sep+"..")
10currdir = dirname(abspath(__file__))+os.sep
11
12import unittest
13from nose.tools import nottest
14from coopr.sucasa import parse_ampl,MILPSymbInfo
15import pyutilib.misc
16import pyutilib.th
17
18class ParserTester(pyutilib.th.TestCase):
19
20    def tearDown(self):
21        if os.path.exists(currdir+"parsetab.py"):
22           os.remove(currdir+"parsetab.py")
23        if os.path.exists(currdir+"parsetab.pyc"):
24           os.remove(currdir+"parsetab.pyc")
25
26    def test_parse1(self):
27        """Parser empty string"""
28        ans = parse_ampl("")
29        tmp = str(ans)
30        self.failUnlessEqual(tmp,"")
31
32    def test_parse2(self):
33        """Parser None"""
34        ans = parse_ampl(None)
35        self.failUnlessEqual(ans,None)
36
37
38    def test_parse3(self):
39        """Parser simple set"""
40        ans = parse_ampl("set a;")
41        tmp = str(ans)
42        self.failUnlessEqual(tmp,"set a [] None")
43
44    def test_parse4(self):
45        """Parser simple param"""
46        ans = parse_ampl("param a;")
47        tmp = str(ans)
48        self.failUnlessEqual(tmp,"param a [] reals")
49
50    def test_parse5(self):
51        """Parser simple var"""
52        ans = parse_ampl("var a;")
53        tmp = str(ans)
54        self.failUnlessEqual(tmp,"var a [] None")
55
56    def test_parse6(self):
57        """Parser simple objective"""
58        ans = parse_ampl("minimize a: 0;")
59        tmp = str(ans)
60        self.failUnlessEqual(tmp,"min a [] None")
61
62    def test_parse7(self):
63        """Parser simple objective"""
64        ans = parse_ampl("maximize a: 0;")
65        tmp = str(ans)
66        self.failUnlessEqual(tmp,"max a [] None")
67
68    def test_parse8(self):
69        """Parser simple constraint"""
70        ans = parse_ampl("subject to a: 0;")
71        tmp = str(ans)
72        self.failUnlessEqual(tmp,"con a [] None")
73
74
75    def test_parse3a(self):
76        """Parser indexed set"""
77        ans = parse_ampl("set a {b};")
78        tmp = str(ans)
79        self.failUnlessEqual(tmp,"set a ['b'] None")
80
81    def test_parse4a(self):
82        """Parser indexed param"""
83        ans = parse_ampl("param a {b};")
84        tmp = str(ans)
85        self.failUnlessEqual(tmp,"param a ['b'] reals")
86
87    def test_parse5a(self):
88        """Parser indexed var"""
89        ans = parse_ampl("var a {b};")
90        tmp = str(ans)
91        self.failUnlessEqual(tmp,"var a ['b'] None")
92
93    def test_parse6a(self):
94        """Parser indexed objective"""
95        ans = parse_ampl("minimize a {b}: 0;")
96        tmp = str(ans)
97        self.failUnlessEqual(tmp,"min a ['b'] None")
98
99    def test_parse7a(self):
100        """Parser indexed objective"""
101        ans = parse_ampl("maximize a {b}: 0;")
102        tmp = str(ans)
103        self.failUnlessEqual(tmp,"max a ['b'] None")
104
105    def test_parse8a(self):
106        """Parser indexed constraint"""
107        ans = parse_ampl("subject to a {b}: 0;")
108        tmp = str(ans)
109        self.failUnlessEqual(tmp,"con a ['b'] None")
110
111
112    def test_parse3b(self):
113        """Parser indexed set"""
114        ans = parse_ampl("set a {b,c};")
115        tmp = str(ans)
116        self.failUnlessEqual(tmp,"set a ['b', 'c'] None")
117
118    def test_parse4b(self):
119        """Parser indexed param"""
120        ans = parse_ampl("param a {b,c};")
121        tmp = str(ans)
122        self.failUnlessEqual(tmp,"param a ['b', 'c'] reals")
123
124    def test_parse5b(self):
125        """Parser indexed var"""
126        ans = parse_ampl("var a {b,c};")
127        tmp = str(ans)
128        self.failUnlessEqual(tmp,"var a ['b', 'c'] None")
129
130    def test_parse6b(self):
131        """Parser indexed objective"""
132        ans = parse_ampl("minimize a {b,c}: 0;")
133        tmp = str(ans)
134        self.failUnlessEqual(tmp,"min a ['b', 'c'] None")
135
136    def test_parse7b(self):
137        """Parser indexed objective"""
138        ans = parse_ampl("maximize a {b,c}: 0;")
139        tmp = str(ans)
140        self.failUnlessEqual(tmp,"max a ['b', 'c'] None")
141
142    def test_parse8b(self):
143        """Parser indexed constraint"""
144        ans = parse_ampl("subject to a {b,c}: 0;")
145        tmp = str(ans)
146        self.failUnlessEqual(tmp,"con a ['b', 'c'] None")
147
148
149    def test_parse3c(self):
150        """Parser indexed set"""
151        ans = parse_ampl("set a {b,c,d};")
152        tmp = str(ans)
153        self.failUnlessEqual(tmp,"set a ['b', 'c', 'd'] None")
154
155    def test_parse4c(self):
156        """Parser indexed param"""
157        ans = parse_ampl("param a {b,c,d};")
158        tmp = str(ans)
159        self.failUnlessEqual(tmp,"param a ['b', 'c', 'd'] reals")
160
161    def test_parse5c(self):
162        """Parser indexed var"""
163        ans = parse_ampl("var a {b,c,d};")
164        tmp = str(ans)
165        self.failUnlessEqual(tmp,"var a ['b', 'c', 'd'] None")
166
167    def test_parse6c(self):
168        """Parser indexed objective"""
169        ans = parse_ampl("minimize a {b,c,d}: 0;")
170        tmp = str(ans)
171        self.failUnlessEqual(tmp,"min a ['b', 'c', 'd'] None")
172
173    def test_parse7c(self):
174        """Parser indexed objective"""
175        ans = parse_ampl("maximize a {b,c,d}: 0;")
176        tmp = str(ans)
177        self.failUnlessEqual(tmp,"max a ['b', 'c', 'd'] None")
178
179    def test_parse8c(self):
180        """Parser indexed constraint"""
181        ans = parse_ampl("subject to a {b,c,d}: 0;")
182        tmp = str(ans)
183        self.failUnlessEqual(tmp,"con a ['b', 'c', 'd'] None")
184
185
186    def test_parse10(self):
187        """Parse comments"""
188        ans = parse_ampl("# a comment line")
189        tmp=str(ans)
190        self.failUnlessEqual(tmp,"")
191        ans = parse_ampl("# SUCASA SYMBOLS: a b")
192        tmp=str(ans)
193        self.failUnlessEqual(tmp,"")
194        ans = parse_ampl("#SUCASA SYMBOLS: a b")
195        tmp=str(ans)
196        self.failUnlessEqual(tmp,"")
197        ans = parse_ampl("# SUCASA set A")
198        tmp=str(ans)
199        self.failUnlessEqual(tmp,"set A None None")
200        ans = parse_ampl("#SUCASA set a")
201        tmp=str(ans)
202        self.failUnlessEqual(tmp,"set a None None")
203
204    def test_parse11(self):
205        """Parse check statement"""
206        ans = parse_ampl("check : i >= 1;")
207        tmp=str(ans)
208        self.failUnlessEqual(tmp,"")
209
210    def test_parse12(self):
211        """Parse comma-separated values for parameter declaration"""
212        ans = parse_ampl("param i >= 1, <= 2 := 0;")
213        tmp=str(ans)
214        self.failUnlessEqual(tmp,"param i [] reals")
215
216    def test_parse13a(self):
217        """Parse index declaration that involves a set expression"""
218        ans = parse_ampl("param i{ a in A };")
219        tmp=str(ans)
220        self.failUnlessEqual(tmp,"param i ['A'] reals")
221
222    def test_parse13b(self):
223        """Parse index declaration that involves a set expression"""
224        ans = parse_ampl("param i{ a in A[j] };")
225        tmp=str(ans)
226        self.failUnlessEqual(tmp,"param i ['A [ j ]'] reals")
227
228    def test_parse13c(self):
229        """Parse index declaration that involves a set expression"""
230        ans = parse_ampl("param i{ a in A[j] : a>0 };")
231        tmp=str(ans)
232        self.failUnlessEqual(tmp,"param i ['A [ j ]'] reals")
233
234    def test_data1(self):
235        """Parse data"""
236        pyutilib.misc.setup_redirect(currdir+"data1.out")
237        ans = parse_ampl("data;",debug=1)
238        pyutilib.misc.reset_redirect()
239        os.remove(currdir+"data1.out")
240        tmp=str(ans)
241        self.failUnlessEqual(tmp,"")
242        ans = parse_ampl("data; set a := (1,2) (3,4);")
243        tmp=str(ans)
244        self.failUnlessEqual(tmp,"")
245
246    def test_ampl1(self):
247        """Test parser with ampl1.mod"""
248        ans = parse_ampl(filename=currdir+"ampl1.mod")
249        pyutilib.misc.setup_redirect(currdir+"ampl1.out")
250        print str(ans)
251        pyutilib.misc.reset_redirect()
252        self.failUnlessFileEqualsBaseline(currdir+"ampl1.out",currdir+"ampl1.txt")
253       
254    def test_ampl1_map(self):
255        """Test mapfile generation with ampl1.mod"""
256        ans = parse_ampl(filename=currdir+"ampl1.mod")
257        info = MILPSymbInfo()
258        ans.initialize(info)
259        info.write_mapfile(filename=currdir+"ampl1.out",quiet=True)
260        self.failUnlessFileEqualsBaseline(currdir+"ampl1.out",currdir+"ampl1.map")
261
262    def test_ampl2(self):
263        """Test mapfile generation with ampl2.mod"""
264        ans = parse_ampl(filename=currdir+"ampl2.mod")
265        info = MILPSymbInfo()
266        ans.initialize(info)
267        info.write_mapfile(filename=currdir+"ampl2.out",quiet=True)
268        self.failUnlessFileEqualsBaseline(currdir+"ampl2.out",currdir+"ampl2.map")
269
270    def test_ampl3(self):
271        """Test mapfile generation with ampl3.mod"""
272        ans = parse_ampl(filename=currdir+"ampl3.mod")
273        info = MILPSymbInfo()
274        ans.initialize(info)
275        info.write_mapfile(filename=currdir+"ampl3.out",quiet=True)
276        self.failUnlessFileEqualsBaseline(currdir+"ampl3.out",currdir+"ampl3.map")
277       
278    def test_error1(self):
279        """Parse empty expression"""
280        try:
281            ans = parse_ampl(";")
282            self.fail("test_error1")
283        except IOError:
284            pass
285
286    def test_error2(self):
287        """Parse illegal character"""
288        try:
289            ans = parse_ampl("set ^ ;")
290            self.fail("test_error2")
291        except IOError:
292            pass
293
294if __name__ == "__main__":
295   unittest.main()
Note: See TracBrowser for help on using the repository browser.