Changeset 2295


Ignore:
Timestamp:
02/09/10 16:23:37 (4 years ago)
Author:
wehart
Message:

Reworking tests to do basic evaluation of the
interface to Excel spreadsheets.

Location:
coopr.pyomo/trunk/coopr/pyomo
Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed
  • coopr.pyomo/trunk/coopr/pyomo/base/plugin.py

    r2227 r2295  
    168168    if name is None: 
    169169        return map(lambda x:x.name, ep()) 
    170     return ep.service(name).create() 
     170    service = ep.service(name) 
     171    if service is None: 
     172        return None 
     173    return service.create() 
    171174 
    172175 
  • coopr.pyomo/trunk/coopr/pyomo/data/TableData.py

    r2292 r2295  
    3030        self.options = Options(**kwds) 
    3131 
    32     def open(self, filename): 
     32    def open(self): 
    3333        """ 
    3434        Open the table 
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_modeldata.py

    r2292 r2295  
    1111from coopr.pyomo import * 
    1212import coopr 
     13import pyutilib.common 
    1314 
    1415currdir=dirname(abspath(__file__))+os.sep 
     
    3738 
    3839    def test_read_set(self): 
    39         td = TableData(filename=coopr_dir+"\\test\\acro\\unit\\Book1.xls",range="TheRange",set="X") 
     40        td = DataManagerFactory('xls') 
     41        td.initialize(currdir+"Book1.xls", range="TheRange", format='set', set="X") 
    4042        try: 
    4143           td.open() 
    4244           td.read() 
    4345           td.close() 
    44            self.failUnlessEqual( td.data(), ['set', 'X', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
    45         except coopr.ApplicationError: 
     46           self.failUnlessEqual( td._info, ['set', 'X', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
     47        except pyutilib.common.ApplicationError: 
    4648           pass 
    4749 
    48     def test_read_set2(self): 
    49         td = TableData(range="TheRange",set="X") 
    50         try: 
    51            td.open(filename=coopr_dir+"\\test\\acro\\unit\\Book1.xls") 
    52            td.read() 
    53            td.close() 
    54            self.failUnlessEqual( td.data(), ['set', 'X', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
    55         except coopr.ApplicationError: 
    56            pass 
    57  
    5850    def test_read_param1(self): 
    59         td = TableData(filename=coopr_dir+"\\test\\acro\\unit\\Book1.xls",range="TheRange") 
     51        td = DataManagerFactory('xls') 
     52        td.initialize(currdir+"Book1.xls", range="TheRange", index=['aa'], param=['bb','cc','dd']) 
    6053        try: 
    6154          td.open() 
    6255          td.read() 
    6356          td.close() 
    64           self.failUnlessEqual( td.data(), ['param', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
    65         except coopr.ApplicationError: 
     57          self.failUnlessEqual( td._info, ['param', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
     58        except pyutilib.common.ApplicationError: 
    6659          pass 
    6760 
    6861    def test_read_param2(self): 
    69         td = TableData(filename=coopr_dir+"\\test\\acro\\unit\\Book1.xls",range="TheRange",index="X") 
     62        td = DataManagerFactory('xls') 
     63        td.initialize(currdir+"Book1.xls",range="TheRange", index_name="X", index=['aa'], param=['bb','cc','dd']) 
    7064        try: 
    7165          td.open() 
    7266          td.read() 
    7367          td.close() 
    74           self.failUnlessEqual( td.data(), ['param', ':', 'X', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
    75         except coopr.ApplicationError: 
     68          self.failUnlessEqual( td._info, ['param', ':', 'X', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
     69        except pyutilib.common.ApplicationError: 
    7670          pass 
    7771 
    7872    def test_read_param3(self): 
    79         td = TableData(filename=coopr_dir+"\\test\\acro\\unit\\Book1.xls",range="TheRange",index="X", param="a") 
     73        td = DataManagerFactory('xls') 
     74        td.initialize(currdir+"Book1.xls",range="TheRange", index_name="X", index=['aa','bb','cc'], param=["dd"], param_name={'dd':'a'}) 
    8075        try: 
    8176          td.open() 
    8277          td.read() 
    8378          td.close() 
    84           self.failUnlessEqual( td.data(), ['param', ':', 'X', ':', 'a', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
    85         except coopr.ApplicationError: 
     79          self.failUnlessEqual( td._info, ['param', ':', 'X', ':', 'a', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
     80        except pyutilib.common.ApplicationError: 
    8681          pass 
    8782 
    8883    def test_read_param4(self): 
    89         td = TableData(filename=coopr_dir+"\\test\\acro\\unit\\Book1.xls",range="TheRange",index="X", param=("a","b")) 
     84        td = DataManagerFactory('xls') 
     85        td.initialize(currdir+"Book1.xls",range="TheRange", index_name="X", index=['aa','bb'], param=['cc','dd'], param_name={'cc':'a', 'dd':'b'}) 
    9086        try: 
    9187          td.open() 
    9288          td.read() 
    9389          td.close() 
    94           self.failUnlessEqual( td.data(), ['param', ':', 'X', ':', 'a', 'b', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
    95         except coopr.ApplicationError: 
     90          self.failUnlessEqual( td._info, ['param', ':', 'X', ':', 'a', 'b', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
     91        except pyutilib.common.ApplicationError: 
    9692          pass 
    9793 
    9894    def test_read_array1(self): 
    99         td = TableData(filename=coopr_dir+"\\test\\acro\\unit\\Book1.xls",range="TheRange",param="X", format="array") 
     95        td = DataManagerFactory('xls') 
     96        td.initialize(currdir+"Book1.xls",range="TheRange", param="X", format="array") 
    10097        try: 
    10198          td.open() 
    10299          td.read() 
    103100          td.close() 
    104           self.failUnlessEqual( td.data(), ['param', 'X', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
    105         except coopr.ApplicationError: 
     101          self.failUnlessEqual( td._info, ['param', 'X', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
     102        except pyutilib.common.ApplicationError: 
    106103          pass 
    107104 
    108105    def test_read_array2(self): 
    109         td = TableData(filename=coopr_dir+"\\test\\acro\\unit\\Book1.xls",range="TheRange",param="X",format="transposed_array") 
     106        td = DataManagerFactory('xls') 
     107        td.initialize(currdir+"Book1.xls",range="TheRange",param="X",format="transposed_array") 
    110108        try: 
    111109          td.open() 
    112110          td.read() 
    113111          td.close() 
    114           self.failUnlessEqual( td.data(), ['param', 'X', '(tr)',':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
    115         except coopr.ApplicationError: 
     112          self.failUnlessEqual( td._info, ['param', 'X', '(tr)',':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0]) 
     113        except pyutilib.common.ApplicationError: 
    116114          pass 
    117115 
    118116    def test_error1(self): 
    119         td = TableData(filename="bad") 
     117        td = DataManagerFactory('xls') 
     118        td.initialize("bad") 
    120119        try: 
    121120            td.open() 
     
    125124 
    126125    def test_error2(self): 
    127         td = TableData() 
     126        td = DataManagerFactory('xls') 
    128127        try: 
    129128            td.open() 
    130129            self.fail("Expected IOError because no file specified") 
    131         except IOError: 
     130        except (IOError,AttributeError): 
    132131            pass 
    133132 
    134133    def test_error3(self): 
    135         td = TableData(filename=currdir+"display.txt") 
    136         try: 
     134        td = DataManagerFactory('txt') 
     135        try: 
     136            td.initialize(currdir+"display.txt") 
    137137            td.open() 
    138138            self.fail("Expected IOError because of bad file type") 
    139         except IOError: 
     139        except (IOError, AttributeError): 
    140140            pass 
    141141 
    142142    def test_error4(self): 
    143         td = TableData(filename=currdir+"dummy") 
    144         try: 
     143        td = DataManagerFactory('txt') 
     144        try: 
     145            td.initialize(filename=currdir+"dummy") 
    145146            td.open() 
    146147            self.fail("Expected IOError because of bad file type") 
    147         except IOError: 
     148        except (IOError, AttributeError): 
    148149            pass 
    149150 
    150151    def test_error5(self): 
    151         td = TableData(filename=example_dir+"D.tab", param="D", format="foo") 
     152        td = DataManagerFactory('tab') 
     153        td.initialize(example_dir+"D.tab", param="D", format="foo") 
    152154        td.open() 
    153155        try: 
     
    156158        except ValueError: 
    157159            pass 
    158  
    159     def test_error7(self): 
    160         td = TableData(filename=example_dir+"D.tab", set="D", format="foo") 
    161         td.open() 
    162         try: 
    163             td.read() 
    164             self.fail("Expected IOError because of bad format") 
    165         except ValueError: 
    166             pass 
    167  
    168160 
    169161 
     
    502494 
    503495 
    504 class TestModelData(unittest.TestCase): 
     496#class TestSpreadsheet(unittest.TestCase): 
     497class TestSpreadsheet(object): 
    505498 
    506499    def test_tableA1(self): 
    507500        """Importing a single column of data""" 
    508         md = ModelData() 
    509         md.add(os.path.abspath(example_dir+'A.tab'), format='set', set='A') 
    510         model=Model() 
    511         model.A = Set() 
    512         md.read(model) 
    513         instance = model.create(md) 
     501        pyutilib.misc.setup_redirect(currdir+'importA1.dat') 
     502        print "import "+os.path.abspath(example_dir+'A.tab')+" format=set: A;" 
     503        pyutilib.misc.reset_redirect() 
     504        model=Model() 
     505        model.A = Set() 
     506        instance = model.create(currdir+'importA1.dat') 
    514507        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3'])) 
     508        os.remove(currdir+'importA1.dat') 
    515509 
    516510    def test_tableA2(self): 
    517511        """Importing a single column of data""" 
    518         md = ModelData() 
    519         md.add(os.path.abspath(example_dir+'A.tab')) 
    520         model=Model() 
    521         model.A = Set() 
    522         try: 
    523             md.read(model) 
    524             instance = model.create(md) 
     512        pyutilib.misc.setup_redirect(currdir+'importA2.dat') 
     513        print "import "+os.path.abspath(example_dir+'A.tab')+" ;" 
     514        pyutilib.misc.reset_redirect() 
     515        model=Model() 
     516        model.A = Set() 
     517        try: 
     518            instance = model.create(currdir+'importA2.dat') 
    525519            self.fail("Should fail because no set name is specified") 
    526520        except IOError: 
    527521            pass 
     522        os.remove(currdir+'importA2.dat') 
    528523 
    529524    def test_tableA3(self): 
    530525        """Importing a single column of data""" 
    531         md = ModelData() 
    532         md.add(os.path.abspath(example_dir+'A.tab'), set='A') 
    533         model=Model() 
    534         model.A = Set() 
    535         try: 
    536             md.read(model) 
    537             instance = model.create(md) 
     526        pyutilib.misc.setup_redirect(currdir+'importA3.dat') 
     527        print "import "+os.path.abspath(example_dir+'A.tab')+" : A ;" 
     528        pyutilib.misc.reset_redirect() 
     529        model=Model() 
     530        model.A = Set() 
     531        try: 
     532            instance = model.create(currdir+'importA3.dat') 
    538533            self.fail("Should fail because no index is specified") 
    539534        except IOError: 
    540535            pass 
     536        os.remove(currdir+'importA3.dat') 
    541537 
    542538    def test_tableB(self): 
    543539        """Same as test_tableA""" 
    544         md = ModelData() 
    545         md.add(os.path.abspath(example_dir+'B.tab'), format='set', set='B') 
    546         model=Model() 
    547         model.B = Set() 
    548         md.read(model) 
    549         instance = model.create(md) 
     540        pyutilib.misc.setup_redirect(currdir+'importB.dat') 
     541        print "import "+os.path.abspath(example_dir+'B.tab')+" format=set:B;" 
     542        pyutilib.misc.reset_redirect() 
     543        model=Model() 
     544        model.B = Set() 
     545        instance = model.create(currdir+'importB.dat') 
    550546        self.failUnlessEqual(instance.B.data(), set([1, 2, 3])) 
     547        os.remove(currdir+'importB.dat') 
    551548 
    552549    def test_tableC(self): 
    553550        """Importing a multi-column table, where all columns are 
    554551        treated as values for a set with tuple values.""" 
    555         md = ModelData() 
    556         md.add(os.path.abspath(example_dir+'C.tab'), format='set', set='C') 
     552        pyutilib.misc.setup_redirect(currdir+'importC.dat') 
     553        print "import "+os.path.abspath(example_dir+'C.tab')+" format=set: C ;" 
     554        pyutilib.misc.reset_redirect() 
    557555        model=Model() 
    558556        model.C = Set(dimen=2) 
    559         md.read(model) 
    560         instance = model.create(md) 
     557        instance = model.create(currdir+'importC.dat') 
    561558        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)])) 
     559        os.remove(currdir+'importC.dat') 
    562560 
    563561    def test_tableD(self): 
    564562        """Importing a 2D array of data as a set.""" 
    565         md = ModelData() 
    566         md.add(os.path.abspath(example_dir+'D.tab'), format='set_array', set='C') 
     563        pyutilib.misc.setup_redirect(currdir+'importD.dat') 
     564        print "import "+os.path.abspath(example_dir+'D.tab')+" format=set_array: C ;" 
     565        pyutilib.misc.reset_redirect() 
    567566        model=Model() 
    568567        model.C = Set(dimen=2) 
    569         md.read(model) 
    570         instance = model.create(md) 
     568        instance = model.create(currdir+'importD.dat') 
    571569        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)])) 
     570        os.remove(currdir+'importD.dat') 
    572571 
    573572    def test_tableZ(self): 
    574573        """Importing a single parameter""" 
    575         md = ModelData() 
    576         md.add(os.path.abspath(example_dir+'Z.tab'), format='param', param='Z') 
     574        pyutilib.misc.setup_redirect(currdir+'importZ.dat') 
     575        print "import "+os.path.abspath(example_dir+'Z.tab')+" format=param: Z ;" 
     576        pyutilib.misc.reset_redirect() 
    577577        model=Model() 
    578578        model.Z = Param(default=99.0) 
    579         md.read(model) 
    580         instance = model.create(md) 
     579        instance = model.create(currdir+'importZ.dat') 
    581580        self.failUnlessEqual(instance.Z.value, 1.1) 
     581        os.remove(currdir+'importZ.dat') 
    582582 
    583583    def test_tableY(self): 
    584584        """Same as tableXW.""" 
    585         md = ModelData() 
    586         md.add(os.path.abspath(example_dir+'Y.tab'), index=['A'], param=['Y']) 
     585        pyutilib.misc.setup_redirect(currdir+'importY.dat') 
     586        print "import "+os.path.abspath(example_dir+'Y.tab')+" : [A] Y;" 
     587        pyutilib.misc.reset_redirect() 
    587588        model=Model() 
    588589        model.A = Set(initialize=['A1','A2','A3','A4']) 
    589590        model.Y = Param(model.A) 
    590         md.read(model) 
    591         instance = model.create(md) 
     591        instance = model.create(currdir+'importY.dat') 
    592592        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4'])) 
    593593        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5}) 
     594        os.remove(currdir+'importY.dat') 
    594595 
    595596    def test_tableXW_1(self): 
     
    597598        parameter columns.  The first column is assumed to represent an 
    598599        index column.""" 
    599         md = ModelData() 
    600         md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W']) 
     600        pyutilib.misc.setup_redirect(currdir+'importXW.dat') 
     601        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;" 
     602        pyutilib.misc.reset_redirect() 
    601603        model=Model() 
    602604        model.A = Set(initialize=['A1','A2','A3','A4']) 
    603605        model.X = Param(model.A) 
    604606        model.W = Param(model.A) 
    605         md.read(model) 
    606         instance = model.create(md) 
     607        instance = model.create(currdir+'importXW.dat') 
    607608        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4'])) 
    608609        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5}) 
    609610        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5}) 
     611        os.remove(currdir+'importXW.dat') 
    610612 
    611613    def test_tableXW_2(self): 
    612614        """Like test_tableXW_1, except that set A is not defined.""" 
    613         md = ModelData() 
    614         md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W']) 
     615        pyutilib.misc.setup_redirect(currdir+'importXW.dat') 
     616        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;" 
     617        pyutilib.misc.reset_redirect() 
    615618        model=Model() 
    616619        model.A = Set() 
    617620        model.X = Param(model.A) 
    618621        model.W = Param(model.A) 
    619         md.read(model) 
    620         instance = model.create(md) 
     622        instance = model.create(currdir+'importXW.dat') 
    621623        self.failUnlessEqual(instance.A.data(), set()) 
    622624        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5}) 
    623625        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5}) 
     626        os.remove(currdir+'importXW.dat') 
    624627 
    625628    def test_tableXW_3(self): 
    626629        """Like test_tableXW_1, except that set A is defined in the import statment.""" 
    627         md = ModelData() 
    628         md.add(os.path.abspath(example_dir+'XW.tab'), index_name='A', index=['A'], param=['X','W']) 
     630        pyutilib.misc.setup_redirect(currdir+'importXW.dat') 
     631        print "import "+os.path.abspath(example_dir+'XW.tab')+": A=[A] X W;" 
     632        pyutilib.misc.reset_redirect() 
    629633        model=Model() 
    630634        model.A = Set() 
    631635        model.X = Param(model.A) 
    632636        model.W = Param(model.A) 
    633         md.read(model) 
    634         instance = model.create(md) 
     637        instance = model.create(currdir+'importXW.dat') 
    635638        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3'])) 
    636639        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5}) 
    637640        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5}) 
     641        os.remove(currdir+'importXW.dat') 
    638642 
    639643    def test_tableXW_4(self): 
    640644        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped.""" 
    641         md = ModelData() 
    642         md.add(os.path.abspath(example_dir+'XW.tab'), index_name='B', index=['A'], param=['X','W'], param_name={'X':'R', 'W':'S'}) 
     645        pyutilib.misc.setup_redirect(currdir+'importXW.dat') 
     646        print "import "+os.path.abspath(example_dir+'XW.tab')+": B=[A] R=X S=W;" 
     647        pyutilib.misc.reset_redirect() 
    643648        model=Model() 
    644649        model.B = Set() 
    645650        model.R = Param(model.B) 
    646651        model.S = Param(model.B) 
    647         md.read(model) 
    648         instance = model.create(md) 
     652        instance = model.create(currdir+'importXW.dat') 
    649653        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3'])) 
    650654        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5}) 
    651655        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5}) 
     656        os.remove(currdir+'importXW.dat') 
    652657 
    653658    def test_tableT(self): 
    654659        """Importing a 2D array of parameters that are transposed.""" 
    655         md = ModelData() 
    656         md.add(os.path.abspath(example_dir+'T.tab'), format='transposed_array', param='T') 
     660        pyutilib.misc.setup_redirect(currdir+'importT.dat') 
     661        print "import "+os.path.abspath(example_dir+'T.tab')+" format=transposed_array : T;" 
     662        pyutilib.misc.reset_redirect() 
    657663        model=Model() 
    658664        model.A = Set() 
    659665        model.B = Set() 
    660666        model.T = Param(model.A, model.B) 
    661         md.read(model) 
    662         instance = model.create(md) 
     667        instance = model.create(currdir+'importT.dat') 
    663668        self.failUnlessEqual(instance.T.data(), {('A2', 'I1'): 2.3, ('A1', 'I2'): 1.4, ('A1', 'I3'): 1.5, ('A1', 'I4'): 1.6, ('A1', 'I1'): 1.3, ('A3', 'I4'): 3.6, ('A2', 'I4'): 2.6, ('A3', 'I1'): 3.3, ('A2', 'I3'): 2.5, ('A3', 'I2'): 3.4, ('A2', 'I2'): 2.4, ('A3', 'I3'): 3.5}) 
     669        os.remove(currdir+'importT.dat') 
    664670 
    665671    def test_tableU(self): 
    666672        """Importing a 2D array of parameters.""" 
    667         md = ModelData() 
    668         md.add(os.path.abspath(example_dir+'T.tab'), format='array', param='U') 
     673        pyutilib.misc.setup_redirect(currdir+'importU.dat') 
     674        print "import "+os.path.abspath(example_dir+'U.tab')+" format=array : U;" 
     675        pyutilib.misc.reset_redirect() 
    669676        model=Model() 
    670677        model.A = Set() 
    671678        model.B = Set() 
    672679        model.U = Param(model.A, model.B) 
    673         md.read(model) 
    674         instance = model.create(md) 
     680        instance = model.create(currdir+'importU.dat') 
    675681        self.failUnlessEqual(instance.U.data(), {('I2', 'A1'): 1.4, ('I3', 'A1'): 1.5, ('I3', 'A2'): 2.5, ('I4', 'A1'): 1.6, ('I3', 'A3'): 3.5, ('I1', 'A2'): 2.3, ('I4', 'A3'): 3.6, ('I1', 'A3'): 3.3, ('I4', 'A2'): 2.6, ('I2', 'A3'): 3.4, ('I1', 'A1'): 1.3, ('I2', 'A2'): 2.4}) 
     682        os.remove(currdir+'importU.dat') 
    676683 
    677684    def test_tableS(self): 
     
    679686        parameter columns.  The first column is assumed to represent an 
    680687        index column.  A missing value is represented in the column data.""" 
    681         md = ModelData() 
    682         md.add(os.path.abspath(example_dir+'S.tab'), index=['A'], param=['S']) 
     688        pyutilib.misc.setup_redirect(currdir+'importS.dat') 
     689        print "import "+os.path.abspath(example_dir+'S.tab')+": [A] S ;" 
     690        pyutilib.misc.reset_redirect() 
    683691        model=Model() 
    684692        model.A = Set(initialize=['A1','A2','A3','A4']) 
    685693        model.S = Param(model.A) 
    686         md.read(model) 
    687         instance = model.create(md) 
     694        instance = model.create(currdir+'importS.dat') 
    688695        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4'])) 
    689696        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5}) 
     697        os.remove(currdir+'importS.dat') 
    690698 
    691699    def test_tablePO(self): 
     
    694702        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;" 
    695703        pyutilib.misc.reset_redirect() 
    696         md = ModelData() 
    697         md.add(os.path.abspath(example_dir+'PO.tab'), index_name='J', index=['A','B'], param=['P','O']) 
    698704        model=Model() 
    699705        model.J = Set(dimen=2) 
    700706        model.P = Param(model.J) 
    701707        model.O = Param(model.J) 
    702         md.read(model) 
    703         instance = model.create(md) 
     708        instance = model.create(currdir+'importPO.dat') 
    704709        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) ) 
    705710        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} ) 
    706711        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4}) 
     712        os.remove(currdir+'importPO.dat') 
     713 
     714 
     715class TestModelData(unittest.TestCase): 
     716 
     717    def test_tableA1(self): 
     718        """Importing a single column of data""" 
     719        md = ModelData() 
     720        md.add(os.path.abspath(example_dir+'A.tab'), format='set', set='A') 
     721        model=Model() 
     722        model.A = Set() 
     723        md.read(model) 
     724        instance = model.create(md) 
     725        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3'])) 
     726 
     727    def test_tableA2(self): 
     728        """Importing a single column of data""" 
     729        md = ModelData() 
     730        md.add(os.path.abspath(example_dir+'A.tab')) 
     731        model=Model() 
     732        model.A = Set() 
     733        try: 
     734            md.read(model) 
     735            instance = model.create(md) 
     736            self.fail("Should fail because no set name is specified") 
     737        except IOError: 
     738            pass 
     739 
     740    def test_tableA3(self): 
     741        """Importing a single column of data""" 
     742        md = ModelData() 
     743        md.add(os.path.abspath(example_dir+'A.tab'), set='A') 
     744        model=Model() 
     745        model.A = Set() 
     746        try: 
     747            md.read(model) 
     748            instance = model.create(md) 
     749            self.fail("Should fail because no index is specified") 
     750        except IOError: 
     751            pass 
     752 
     753    def test_tableB(self): 
     754        """Same as test_tableA""" 
     755        md = ModelData() 
     756        md.add(os.path.abspath(example_dir+'B.tab'), format='set', set='B') 
     757        model=Model() 
     758        model.B = Set() 
     759        md.read(model) 
     760        instance = model.create(md) 
     761        self.failUnlessEqual(instance.B.data(), set([1, 2, 3])) 
     762 
     763    def test_tableC(self): 
     764        """Importing a multi-column table, where all columns are 
     765        treated as values for a set with tuple values.""" 
     766        md = ModelData() 
     767        md.add(os.path.abspath(example_dir+'C.tab'), format='set', set='C') 
     768        model=Model() 
     769        model.C = Set(dimen=2) 
     770        md.read(model) 
     771        instance = model.create(md) 
     772        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)])) 
     773 
     774    def test_tableD(self): 
     775        """Importing a 2D array of data as a set.""" 
     776        md = ModelData() 
     777        md.add(os.path.abspath(example_dir+'D.tab'), format='set_array', set='C') 
     778        model=Model() 
     779        model.C = Set(dimen=2) 
     780        md.read(model) 
     781        instance = model.create(md) 
     782        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)])) 
     783 
     784    def test_tableZ(self): 
     785        """Importing a single parameter""" 
     786        md = ModelData() 
     787        md.add(os.path.abspath(example_dir+'Z.tab'), format='param', param='Z') 
     788        model=Model() 
     789        model.Z = Param(default=99.0) 
     790        md.read(model) 
     791        instance = model.create(md) 
     792        self.failUnlessEqual(instance.Z.value, 1.1) 
     793 
     794    def test_tableY(self): 
     795        """Same as tableXW.""" 
     796        md = ModelData() 
     797        md.add(os.path.abspath(example_dir+'Y.tab'), index=['A'], param=['Y']) 
     798        model=Model() 
     799        model.A = Set(initialize=['A1','A2','A3','A4']) 
     800        model.Y = Param(model.A) 
     801        md.read(model) 
     802        instance = model.create(md) 
     803        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4'])) 
     804        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5}) 
     805 
     806    def test_tableXW_1(self): 
     807        """Importing a table, but only reporting the values for the non-index  
     808        parameter columns.  The first column is assumed to represent an 
     809        index column.""" 
     810        md = ModelData() 
     811        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W']) 
     812        model=Model() 
     813        model.A = Set(initialize=['A1','A2','A3','A4']) 
     814        model.X = Param(model.A) 
     815        model.W = Param(model.A) 
     816        md.read(model) 
     817        instance = model.create(md) 
     818        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4'])) 
     819        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5}) 
     820        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5}) 
     821 
     822    def test_tableXW_2(self): 
     823        """Like test_tableXW_1, except that set A is not defined.""" 
     824        md = ModelData() 
     825        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W']) 
     826        model=Model() 
     827        model.A = Set() 
     828        model.X = Param(model.A) 
     829        model.W = Param(model.A) 
     830        md.read(model) 
     831        instance = model.create(md) 
     832        self.failUnlessEqual(instance.A.data(), set()) 
     833        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5}) 
     834        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5}) 
     835 
     836    def test_tableXW_3(self): 
     837        """Like test_tableXW_1, except that set A is defined in the import statment.""" 
     838        md = ModelData() 
     839        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='A', index=['A'], param=['X','W']) 
     840        model=Model() 
     841        model.A = Set() 
     842        model.X = Param(model.A) 
     843        model.W = Param(model.A) 
     844        md.read(model) 
     845        instance = model.create(md) 
     846        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3'])) 
     847        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5}) 
     848        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5}) 
     849 
     850    def test_tableXW_4(self): 
     851        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped.""" 
     852        md = ModelData() 
     853        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='B', index=['A'], param=['X','W'], param_name={'X':'R', 'W':'S'}) 
     854        model=Model() 
     855        model.B = Set() 
     856        model.R = Param(model.B) 
     857        model.S = Param(model.B) 
     858        md.read(model) 
     859        instance = model.create(md) 
     860        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3'])) 
     861        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5}) 
     862        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5}) 
     863 
     864    def test_tableT(self): 
     865        """Importing a 2D array of parameters that are transposed.""" 
     866        md = ModelData() 
     867        md.add(os.path.abspath(example_dir+'T.tab'), format='transposed_array', param='T') 
     868        model=Model() 
     869        model.A = Set() 
     870        model.B = Set() 
     871        model.T = Param(model.A, model.B) 
     872        md.read(model) 
     873        instance = model.create(md) 
     874        self.failUnlessEqual(instance.T.data(), {('A2', 'I1'): 2.3, ('A1', 'I2'): 1.4, ('A1', 'I3'): 1.5, ('A1', 'I4'): 1.6, ('A1', 'I1'): 1.3, ('A3', 'I4'): 3.6, ('A2', 'I4'): 2.6, ('A3', 'I1'): 3.3, ('A2', 'I3'): 2.5, ('A3', 'I2'): 3.4, ('A2', 'I2'): 2.4, ('A3', 'I3'): 3.5}) 
     875 
     876    def test_tableU(self): 
     877        """Importing a 2D array of parameters.""" 
     878        md = ModelData() 
     879        md.add(os.path.abspath(example_dir+'T.tab'), format='array', param='U') 
     880        model=Model() 
     881        model.A = Set() 
     882        model.B = Set() 
     883        model.U = Param(model.A, model.B) 
     884        md.read(model) 
     885        instance = model.create(md) 
     886        self.failUnlessEqual(instance.U.data(), {('I2', 'A1'): 1.4, ('I3', 'A1'): 1.5, ('I3', 'A2'): 2.5, ('I4', 'A1'): 1.6, ('I3', 'A3'): 3.5, ('I1', 'A2'): 2.3, ('I4', 'A3'): 3.6, ('I1', 'A3'): 3.3, ('I4', 'A2'): 2.6, ('I2', 'A3'): 3.4, ('I1', 'A1'): 1.3, ('I2', 'A2'): 2.4}) 
     887 
     888    def test_tableS(self): 
     889        """Importing a table, but only reporting the values for the non-index  
     890        parameter columns.  The first column is assumed to represent an 
     891        index column.  A missing value is represented in the column data.""" 
     892        md = ModelData() 
     893        md.add(os.path.abspath(example_dir+'S.tab'), index=['A'], param=['S']) 
     894        model=Model() 
     895        model.A = Set(initialize=['A1','A2','A3','A4']) 
     896        model.S = Param(model.A) 
     897        md.read(model) 
     898        instance = model.create(md) 
     899        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4'])) 
     900        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5}) 
     901 
     902    def test_tablePO(self): 
     903        """Importing a table that has multiple indexing columns""" 
     904        pyutilib.misc.setup_redirect(currdir+'importPO.dat') 
     905        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;" 
     906        pyutilib.misc.reset_redirect() 
     907        md = ModelData() 
     908        md.add(os.path.abspath(example_dir+'PO.tab'), index_name='J', index=['A','B'], param=['P','O']) 
     909        model=Model() 
     910        model.J = Set(dimen=2) 
     911        model.P = Param(model.J) 
     912        model.O = Param(model.J) 
     913        md.read(model) 
     914        instance = model.create(md) 
     915        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) ) 
     916        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} ) 
     917        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4}) 
    707918 
    708919 
Note: See TracChangeset for help on using the changeset viewer.