GME: tc4.py Source File

00001 import unittest
00002 import win32com.client
00003 import win32ui
00004 import pythoncom
00005 import os
00006 import stat
00007 import utils.Builder
00008 bd = utils.Builder
00009 
00010 from GPyUnit.util import DispatchEx
00011 from GPyUnit.util import dec_disable_early_binding
00012 
00013 def _adjacent_file(file):
00014     import os.path
00015     return os.path.join(os.path.dirname(os.path.abspath(__file__)), file)
00016 
00017 class TestCase4( unittest.TestCase ):
00018         #avoid if possible the overriding of __init__, yet if you override use the following form:
00019         #def __init__(self, methodName='runTest'):
00020         #       unittest.TestCase.__init__(self, methodName)
00021 
00022         def setUp( self ):              ## hook method
00023                 pass
00024 
00025         def tearDown( self ):           ## hook method
00026                 self.project.Close( 0 )
00027                 pass
00028         
00029         def scramble_name( self, o_n):
00030                 # shift letters by one character in the range of [32 - 126]
00031                 n_n = ''
00032                 for i in range( len( o_n)):
00033                         n_n = n_n + chr( 32 + (1 + ( ord( o_n[i]) - 32) % (126-32) ))
00034                 return n_n
00035 
00036 
00037         def populate4A(self, p):
00038                 pass
00039         
00040         def testA( self ):
00041                 """   testA
00042 
00043                 Open                            a project
00044                 Preferences                     property inquired
00045                 OperationsMask                  property inquired
00046                 CreateTerritory
00047                 BeginTransaction
00048                 Preferences                     property inquired
00049                 OperationsMask                  property inquired
00050                 Preferences                     property set
00051                 OperationsMask                  property set
00052                 CommitTransaction
00053                 Preferences                     property set to original value
00054                 OperationsMask                  property set to original value
00055                 Save                            project
00056                 Close                           project
00057                 
00058                 """
00059 
00060                 mganame = _adjacent_file("_tc4_A_sf.mga")
00061 
00062                 # create the project with the needed kinds
00063                 project = bd.creaP( mganame, "SF")
00064                 if not project:
00065                         self.fail("Create failed")
00066                 try:
00067                         self.populate4A( project)
00068                 except:
00069                         bd.saveP( project)
00070                         raise
00071                 bd.saveP( project)
00072 
00073 
00074                 # open the created project
00075                 self.project = project
00076                 try:
00077                         project.Open( "MGA=" + mganame )
00078                 except:
00079                         project.Close(0)
00080                         raise
00081                 
00082                 o_pref = project.Preferences
00083                 o_opms = project.OperationsMask
00084                 
00085                 terr = project.CreateTerritory( None, None, None)
00086                 
00087                 trans = project.BeginTransaction( terr)
00088 
00089                 t_pref = project.Preferences
00090                 t_opms = project.OperationsMask
00091                 
00092                 # compare the values when inquired inside a transaction with those out of transaction
00093                 assert t_pref == o_pref
00094                 assert t_opms == o_opms
00095                 
00096                 """
00097                 MGAPREF_NODUPLICATENAMES  = 0x00000001,         // make sure, names are never duplicated
00098                 MGAPREF_NAMENEWOBJECTS    = 0x00000002,         // assign kind/rolename to new objects
00099                 MGAPREF_IGNORECONNCHECKS =  0x00000004,         // do not complain on partially connected simple connections
00100                 MGAPREF_FREEINSTANCEREFS =  0x00000008,         // do not bind refs in subtypes/instances to successors of ref target in basetype 
00101                 MGAPREF_RELAXED_RDATTRTYPES =  0x00000010,      // attributes may be read as types other than the real type
00102                 MGAPREF_RELAXED_WRATTRTYPES =  0x00000020,      // attributes may be written as types other than the real type
00103                 MGAPREF_MANUAL_RELIDS           = 0x00000040,   // relid-s are assigned manually
00104                 """
00105 
00106                 # try the put method inside transaction
00107                 n_pref = 0x00000002
00108                 n_opms = 0x40
00109                 project.Preferences = n_pref
00110                 project.OperationsMask = n_opms
00111                 
00112                 assert project.Preferences == n_pref
00113                 assert project.OperationsMask == n_opms
00114                 
00115                 project.CommitTransaction()
00116                 
00117                 # try the put method outside transactions
00118 
00119                 project.Preferences = o_pref
00120                 project.OperationsMask = o_opms
00121                 
00122                 assert project.Preferences == o_pref
00123                 assert project.OperationsMask == o_opms
00124 
00125                 project.Save()
00126                 project.Close(0)
00127 
00128         def populate4B(self, p):
00129                 pass
00130                 
00131         def testB( self ):
00132                 """    testB
00133 
00134                 Open                            a project
00135                 CreateTerritory
00136                 BeginTransaction
00137                 Name                            property changed
00138                 Comment                         property changed
00139                 ActiveTerritory                 inquired
00140                 CommitTransaction
00141                 Save                            project
00142                 Close                           project
00143                 
00144                 """
00145 
00146                 mganame = _adjacent_file("_tc4_B_sf.mga")
00147 
00148                 # create the project with the needed kinds
00149                 project = bd.creaP( mganame, "SF")
00150                 if not project:
00151                         self.fail("Create failed")
00152                 try:
00153                         self.populate4B( project)
00154                 except:
00155                         bd.saveP( project)
00156                         raise
00157                 bd.saveP( project)
00158 
00159 
00160                 # open the created project
00161                 self.project = project
00162                 try:
00163                         project.Open( "MGA=" + mganame )
00164                 except:
00165                         project.Close(0)
00166                         raise
00167 
00168                 terr = project.CreateTerritory( None, None, None)
00169                 
00170                 trans = project.BeginTransaction( terr)
00171 
00172                 old_name = project.Name
00173                 new_name = self.scramble_name( old_name)
00174 
00175                 # modify and test
00176                 project.Name = new_name
00177                 assert project.Name == new_name
00178 
00179                 # revert and test
00180                 project.Name = old_name
00181                 assert project.Name == old_name
00182 
00183                 old_comm = project.Comment
00184                 new_comm = ' <sp> '.join( old_comm.split(' '))
00185 
00186                 # modify and test
00187                 project.Comment = new_comm
00188                 assert project.Comment == new_comm
00189                 
00190                 # revert and test
00191                 project.Comment = old_comm
00192                 assert project.Comment == old_comm
00193                 
00194                 assert project.ActiveTerritory == terr
00195 
00196                 project.CommitTransaction()
00197 
00198                 project.Save()
00199                 project.Close(0)
00200 
00201         def populate4C(self, p):
00202                 pass
00203 
00204         def testC( self ):
00205                 """    testC
00206 
00207                 ProjectStatus                   inquired
00208                 Open                            a project
00209                 CreateTerritory                 once
00210                 CreateTerritory                 twice
00211                 ProjectStatus                   inquired
00212                 BeginTransaction
00213                 ProjectStatus                   inquired
00214                 Name                            property changed
00215                 Territories                     inquired
00216                 AbortTransaction
00217                 ProjectStatus                   inquired
00218                 BeginTransaction readonly
00219                 ProjectStatus                   inquired
00220                 Name                            property inquired
00221                 CommitTransaction
00222                 ProjectStatus                   inquired
00223                 Save                            project
00224                 Close                           project
00225                 ProjectStatus                   inquired
00226                 
00227                 Project status bits to be interpreted like:
00228                 0 :     is open? 
00229                 1 :     open r/o? 
00230                 2 :     has changed? 
00231                 3 :     in transaction?, 
00232                 4 :     transaction r/o?, 
00233                 31:     error
00234 
00235                 """
00236 
00237                 mganame = _adjacent_file("_tc4_C_sf.mga")
00238 
00239                 # create the project with the needed kinds
00240                 project = bd.creaP( mganame, "SF")
00241                 if not project:
00242                         self.fail("Create failed")
00243                 try:
00244                         self.populate4C( project)
00245                 except:
00246                         bd.saveP( project)
00247                         raise
00248                 bd.saveP( project)
00249 
00250                 stat = project.ProjectStatus
00251                 assert stat & 1 == 0    # is NOT open
00252                 assert stat & 2 == 0    # is NOT read-only
00253                 assert stat & 8 == 0    # is NOT in transaction
00254 
00255                 # provoke error bit
00256                 try :
00257                         project.Open( "MJA=" + mganame ) #intentional error
00258                         # it should fail
00259                         assert 0 
00260                 except:
00261                         stat = project.ProjectStatus
00262                         assert stat & 1 == 0    # is NOT open
00263                         assert stat & 2 == 0    # is NOT read-only
00264                         assert stat & (1 << 31) == 0    # ERROR flag is TRUE
00265 
00266                 # open the created project
00267                 self.project = project
00268                 try:
00269                         project.Open( "MGA=" + mganame )
00270                 except:
00271                         project.Close(0)
00272                         raise
00273 
00274                 terr1 = project.CreateTerritory( None, None, None)
00275                 terr2 = project.CreateTerritory( None, None, None)
00276                 
00277                 stat = project.ProjectStatus
00278                 assert stat & 1 == 1    # is open
00279                 assert stat & 2 == 0    # is NOT read-only
00280                 assert stat & 8 == 0    # is NOT in transaction
00281 
00282                 trans1 = project.BeginTransaction( terr1)
00283 
00284                 stat = project.ProjectStatus
00285                 assert stat & 1 == 1    # is open
00286                 assert stat & 2 == 0    # is NOT read-only
00287                 assert stat & 8 == 8    # is in transaction
00288 
00289                 old_name = project.Name
00290                 new_name = self.scramble_name( old_name)
00291 
00292                 # change the name
00293                 project.Name = new_name
00294                 
00295                 terrs = project.Territories
00296                 assert terrs.Count == 2
00297                 assert terrs[0] in ( terr1, terr2 )
00298                 assert terrs[1] in ( terr1, terr2 )
00299 
00300                 # discard changes
00301                 project.AbortTransaction()
00302 
00303                 stat = project.ProjectStatus
00304                 assert stat & 1 == 1    # is open
00305                 assert stat & 2 == 0    # is NOT read-only
00306                 assert stat & 4 == 0    # project DID NOT change
00307                 assert stat & 8 == 0    # is NOT in transaction
00308 
00309                 # open second TRANSACTION_READ_ONLY = 1
00310                 trans2 = project.BeginTransaction( terr2, 1 )
00311 
00312                 stat = project.ProjectStatus
00313                 assert stat & 1 == 1    # is open
00314                 assert stat & 2 == 0    # is NOT read-only
00315                 assert stat & 8 == 8    # is in transaction
00316                 assert stat & 16== 16   # is in READ-ONLY transaction
00317 
00318                 # name must be equal with the original string since the prev transaction has been aborted
00319                 assert project.Name == old_name
00320 
00321                 project.CommitTransaction()
00322 
00323                 stat = project.ProjectStatus
00324                 assert stat & 1 == 1    # is open
00325                 assert stat & 2 == 0    # is NOT read-only
00326                 assert stat & 8 == 0    # is NOT in transaction
00327 
00328                 project.Save()
00329                 project.Close(0)
00330 
00331                 stat = project.ProjectStatus
00332                 assert stat & 1 == 0    # is NOT open
00333 
00334 
00335 
00336         def populate4D(self, p):
00337                 #it could have been: folder1 = p.RootFolder.CreateFolder( bd.folder( p, 'Folder'))
00338                 # but use the Builder method newInFold
00339                 folder1 = bd.newFolder( p, p.RootFolder, 'Folder')
00340                 folder1.Name = 'FolderA'
00341                 
00342                 #folder2 = p.RootFolder.CreateFolder( bd.folder( p, 'Folder'))
00343                 folder2 = bd.newFolder( p, p.RootFolder, 'Folder')
00344                 folder2.Name = 'FolderB'
00345 
00346                 #it could have been: comp1 = folder1.CreateRootObject( bd.kind( p, 'Compound'))
00347                 # but :
00348                 comp1   = bd.newObjInFold( p, folder1, 'Compound')
00349                 comp1.Name = 'CompoundA'
00350                 
00351                 #it could have been: comp2 = folder2.CreateRootObject( bd.kind( p, 'Compound'))
00352                 # but :
00353                 comp2   = bd.newObjInFold( p, folder2, 'Compound')
00354                 comp2.Name = 'CompoundB'
00355                 
00356 
00357         def testD( self ):
00358                 """    testD
00359 
00360                 Open                            a project
00361                 BeginTransaction                1st
00362                 RootFolder                      accessed
00363                 Name                            changed
00364                 CommitTransaction
00365                 BeginTransaction                2nd
00366                 RootFolder                      accessed
00367                 Children                        deleted
00368                 CommitTransaction
00369                 UndoRedoSize
00370                 Undo
00371                 BeginTransaction                3rd
00372                 UndoRedoSize
00373                 Redo
00374                 BeginTransaction                4th
00375                 UndoRedoSize
00376                 FlushUndoQueue
00377                 Save                            project
00378                 Close                           project
00379                 
00380                 """
00381 
00382                 mganame = _adjacent_file("_tc4_D_sf.mga")
00383 
00384                 # create the project with the needed kinds
00385                 project = bd.creaP( mganame, "SF")
00386                 if not project:
00387                         self.fail("Create failed")
00388                 try:
00389                         self.populate4D( project)
00390                 except:
00391                         bd.saveP( project)
00392                         raise
00393                 bd.saveP( project)
00394 
00395 
00396                 # open the created project
00397                 self.project = project
00398                 try:
00399                         project.Open( "MGA=" + mganame )
00400                 except:
00401                         project.Close(0)
00402                         raise
00403 
00404                 terr = project.CreateTerritory( None, None, None)
00405                 
00406                 # 1st transaction: change rootfolder's name
00407                 trans = project.BeginTransaction( terr)
00408                 rf = project.RootFolder
00409 
00410                 old_name = rf.Name
00411                 new_name = self.scramble_name( old_name )
00412                 
00413                 rf.Name = new_name      # name changed
00414 
00415                 project.CommitTransaction()
00416 
00417                 # 2nd transaction: delete all objects
00418                 tran2 = project.BeginTransaction( terr)
00419                 rf = project.RootFolder
00420 
00421                 ls_flds = rf.ChildFolders
00422                 ls_chls = rf.ChildFCOs
00423 
00424                 number_of_deleted_objects = ls_flds.Count + ls_chls.Count
00425 
00426                 for fld_i in ls_flds:
00427                         fld_i.DestroyObject()
00428                 for chl_i in ls_chls:
00429                         chl_i.DestroyObject()
00430 
00431                 project.CommitTransaction()
00432                 
00433                 (u, r) = project.UndoRedoSize()
00434                 assert u == 2
00435                 self.assertEqual(r, 0)
00436 
00437                 project.Undo()
00438 
00439                 # 3rd transaction: check the number of objects after Undo
00440                 tran3 = project.BeginTransaction( terr)
00441                 rf = project.RootFolder
00442                 ls_flds = rf.ChildFolders
00443                 ls_chls = rf.ChildFCOs
00444                 project.CommitTransaction()
00445 
00446                 number_of_restored_objects = ls_flds.Count + ls_chls.Count
00447                 
00448                 assert number_of_restored_objects == number_of_deleted_objects
00449 
00450                 (u, r) = project.UndoRedoSize()
00451                 assert u == 1
00452                 self.assertEqual(r, 0)
00453 
00454                 project.Redo()
00455 
00456                 # 4th transaction: check the number of objects after Redo
00457                 tran4 = project.BeginTransaction( terr)
00458                 rf = project.RootFolder
00459                 ls_flds = rf.ChildFolders
00460                 ls_chls = rf.ChildFCOs
00461                 project.CommitTransaction()
00462 
00463                 number_of_objects = ls_flds.Count + ls_chls.Count
00464                 
00465                 assert 0 == number_of_objects
00466 
00467                 (u, r) = project.UndoRedoSize()
00468                 assert u == 2
00469                 self.assertEqual(r, 0)
00470 
00471                 project.FlushUndoQueue()
00472 
00473                 (u, r) = project.UndoRedoSize()
00474                 assert u == 0
00475                 self.assertEqual(r, 0)
00476 
00477 
00478                 project.Save()
00479                 project.Close(0)
00480 
00481 
00482         def register_old_sf_par(self):
00483                 curdir = os.path.abspath(os.path.curdir)
00484                 #curdir = ''
00485                 par_conn_str = "MGA=" + curdir + "used_paradigms\\SF\\SF_older.mta"
00486                 par_con2_str = "XML=" + curdir + "used_paradigms\\SF\\SF_older.xmp"
00487                 ori_conn_str = "MGA=" + curdir + "used_paradigms\\SF\\SF_orig.mta"
00488                 
00489                 registrar = DispatchEx("Mga.MgaRegistrar")
00490                 
00491                 # 1: user registry 
00492                 # 2: system registry
00493                 register_in = 1
00494                 newname = registrar.RegisterParadigmFromData( par_conn_str, None, register_in)
00495                 
00496                 # maybe we have to register the original sf.mta file once again
00497                 newname = registrar.RegisterParadigmFromData( ori_conn_str, None, register_in)
00498                 
00499                 # {5D6FF99D-D6C2-46A5-9208-CCA15D5FA16C} guid of the SF_older.xmp
00500                 # 
00501                 char_guid = ['0x9d', '0xf9', '0x6f', '0x5d', '0xc2', '0xd6', '0xa5', '0x46', '0x92', '0x08', '0xcc', '0xa1', '0x5d', '0x5f', '0xa1', '0x6c']
00502                 bin_guid =  [0x9d, 0xf9, 0x6f, 0x5d, 0xc2, 0xd6, 0xa5, 0x46, 0x92, 0x08, 0xcc, 0xa1, 0x5d, 0x5f, 0xa1, 0x6c]
00503                 
00504                 #return char_guid
00505                 return bin_guid
00506                 
00507                 
00508         def populate4E1(self, p):
00509                 folder1 = bd.newFolder( p, p.RootFolder, 'Folder')
00510                 folder1.Name = 'FolderA'
00511                 
00512                 folder2 = bd.newFolder( p, p.RootFolder, 'Folder')
00513                 folder2.Name = 'FolderB'
00514 
00515                 comp1   = bd.newObjInFold( p, folder1, 'Compound')
00516                 comp1.Name = 'CompoundA'
00517                 
00518                 comp2   = bd.newObjInFold( p, folder2, 'Compound')
00519                 comp2.Name = 'CompoundB'
00520                 
00521         def populate4E3(self, p):
00522                 folder1 = bd.newFolder( p, p.RootFolder, 'Folder')
00523                 folder1.Name = 'FolderA'
00524                 
00525                 folder2 = bd.newFolder( p, p.RootFolder, 'Folder')
00526                 folder2.Name = 'FolderB'
00527 
00528                 comp1   = bd.newObjInFold( p, folder1, 'Compound')
00529                 comp1.Name = 'CompoundA'
00530                 
00531                 comp2   = bd.newObjInFold( p, folder2, 'Compound')
00532                 comp2.Name = 'CompoundB'
00533                 
00534         def populate4E4(self, p):
00535                 folder1 = bd.newFolder( p, p.RootFolder, 'Folder')
00536                 folder1.Name = 'FolderA'
00537                 
00538                 folder2 = bd.newFolder( p, p.RootFolder, 'Folder')
00539                 folder2.Name = 'FolderB'
00540 
00541                 comp1   = bd.newObjInFold( p, folder1, 'Compound')
00542                 comp1.Name = 'CompoundA'
00543                 
00544                 comp2   = bd.newObjInFold( p, folder2, 'Compound')
00545                 comp2.Name = 'CompoundB'
00546                 
00547         def populate4E5(self, p):
00548                 folder1 = bd.newFolder( p, p.RootFolder, 'Folder')
00549                 folder1.Name = 'FolderA'
00550                 
00551                 folder2 = bd.newFolder( p, p.RootFolder, 'Folder')
00552                 folder2.Name = 'FolderB'
00553 
00554                 comp1   = bd.newObjInFold( p, folder1, 'Compound')
00555                 comp1.Name = 'CompoundA'
00556                 
00557                 comp2   = bd.newObjInFold( p, folder2, 'Compound')
00558                 comp2.Name = 'CompoundB'
00559 
00560         def populate4E6(self, p):
00561                 folder1 = bd.newFolder( p, p.RootFolder, 'Folder')
00562                 folder1.Name = 'FolderA'
00563                 
00564                 folder2 = bd.newFolder( p, p.RootFolder, 'Folder')
00565                 folder2.Name = 'FolderB'
00566 
00567                 comp1   = bd.newObjInFold( p, folder1, 'Compound')
00568                 comp1.Name = 'CompoundA'
00569                 
00570                 comp2   = bd.newObjInFold( p, folder2, 'Compound')
00571                 comp2.Name = 'CompoundB'
00572 
00573         @dec_disable_early_binding
00574         def testE1( self ):
00575                 """    testE1
00576 
00577                 Open                            for a readonly project
00578                 """
00579 
00580                 mganame = _adjacent_file("_tc4_E1_readonly_sf.mga")
00581 
00582                 # if file exists from previous testing remove its readonly flag and delete the file
00583                 if os.path.isfile( mganame):
00584                         # revert to read/write permission in order to delete it seamlessly
00585                         os.chmod( mganame, stat.S_IWUSR)
00586 
00587                         #delete:
00588                         #os.remove( mganame)
00589                 
00590 
00591                 # create the project with the needed kinds
00592                 project = bd.creaP( mganame, "SF")
00593                 if not project:
00594                         self.fail("Create failed")
00595                 try:
00596                         self.populate4E1( project)
00597                 except:
00598                         bd.saveP( project)
00599                         raise
00600                 bd.saveP( project)
00601 
00602                 self.project = project
00603 
00604                 # 1st test: open readonly
00605                 # open the created project
00606                 try:
00607                         # make the file read-only
00608                         os.chmod( mganame, stat.S_IRUSR)
00609                         readonly = project.Open( "MGA=" + mganame )
00610                         assert readonly
00611                         
00612                         project.Close(0)
00613                 except:
00614                         project.Close(0)
00615                         raise
00616 
00617         @dec_disable_early_binding
00618         def testE2( self ):
00619                 """    testE2
00620 
00621                 CreateEx                        with an old, registered version of SF
00622                 OpenEx                          with an old, registered version of SF
00623                 Meta                            accessed to test existence of specific kind in the old paradigm
00624                 Close( abort )
00625 
00626                 """
00627                 mganame = _adjacent_file("_tc4_E2_sf.mga")
00628 
00629                 self.project = project = DispatchEx("Mga.MgaProject")
00630 
00631                 charform_guid = self.register_old_sf_par()
00632                 
00633                 try:
00634                         project.CreateEx( "MGA=" + mganame, "SF", charform_guid)
00635                 except:
00636                         project.Close(0)
00637                         raise
00638                 
00639                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00640                 
00641                 try:
00642                         metafco = bd.kind( project, 'Basic')
00643                         if not metafco:
00644                                 print 'Basic kind not found'
00645                                 self.fail('Basic kind not found')
00646                 except:
00647                         print 'Kind not found'
00648                         raise
00649                 
00650                 
00651                 fol1 = bd.newFolder( p, p.RootFolder, 'Folder')
00652                 fol1.Name = 'JustCreated'
00653                 
00654                 bas1 = bd.newObjInFold( p, p.RootFolder, 'Basic')
00655                 bas1.Name = 'Basic1'
00656                 
00657                 project.CommitTransaction()
00658                 project.Close(0)
00659 
00660                 # 2nd test: OpenEx
00661                 try:
00662                         ro = project.OpenEx( "MGA=" + mganame, "SF", charform_guid)
00663                 except:
00664                         print 'OpenEx failed'
00665                         raise
00666 
00667                 try:
00668                         assert not ro   # not readonly
00669                         
00670                         project.BeginTransaction( project.CreateTerritory( None, None, None))
00671                         
00672                         f1 = bd.findInProj( project, 'JustCreated')
00673                         b1 = bd.findInProj( project, 'Basic1')
00674 
00675                         assert f1
00676                         assert b1
00677                         
00678                         assert f1.ID    # valid pointer
00679                         assert b1.ID    # valid pointer
00680                         
00681                         project.CommitTransaction()
00682                         project.Close(0)
00683                 except:
00684                         project.AbortTransaction()
00685                         project.Close(0)
00686                         raise
00687 
00688                 pass
00689                 
00690         @dec_disable_early_binding
00691         def testE3( self ):
00692                 """    testE3
00693                 
00694                 SaveAs          under a different name, with "Don't keep oldname" option
00695                 """
00696                 mganame = _adjacent_file("_tc4_E3_sf.mga")
00697                 mganame_SavedAs = _adjacent_file("_tc4_E3_savedAs_sf.mga")
00698 
00699                 # create the project with the needed kinds
00700                 project = bd.creaP( mganame, "SF")
00701                 if not project:
00702                         self.fail("Create failed")
00703                 try:
00704                         self.populate4E3( project)
00705                 except:
00706                         bd.saveP( project)
00707                         raise
00708                 bd.saveP( project)
00709 
00710                 self.project = project
00711 
00712                 # open the created project
00713                 project.Open( "MGA=" + mganame)
00714 
00715                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00716 
00717                 cA = bd.findInProj( project, 'CompoundA')
00718                 
00719                 pA = bd.new( project, cA, 'InputParameters')
00720                 pA.Name = 'InpPar'
00721                 
00722                 project.CommitTransaction()
00723 
00724                 
00725                 # SAVE_AS operation
00726                 # should create a file, and activate that project
00727                 project.Save( "MGA=" + mganame_SavedAs)
00728                 project.Close(0)
00729                 
00730                 # open the saved as project
00731                 project.Open( "MGA=" + mganame_SavedAs)
00732 
00733                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00734 
00735                 pA = bd.findInProj( project, 'InpPar')
00736                 
00737                 assert pA
00738                 assert pA.ID
00739                 
00740                 project.CommitTransaction()
00741                 project.Close(0)
00742 
00743         @dec_disable_early_binding
00744         def testE4( self ):
00745                 """    testE4
00746                 
00747                 SaveAs          under a different name, with "Don't keep oldname" option
00748                 Apply changes   after the SaveAs operation
00749                 """
00750                 mganame = _adjacent_file("_tc4_E4_sf.mga")
00751                 mganame_SavedAs = _adjacent_file("_tc4_E4_savedAs_sf.mga")
00752 
00753                 # create the project with the needed kinds
00754                 project = bd.creaP( mganame, "SF")
00755                 if not project:
00756                         self.fail("Create failed")
00757                 try:
00758                         self.populate4E4( project)
00759                 except:
00760                         bd.saveP( project)
00761                         raise
00762                 bd.saveP( project)
00763 
00764                 self.project = project
00765 
00766                 # open the created project
00767                 project.Open( "MGA=" + mganame)
00768 
00769                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00770 
00771                 cA = bd.findInProj( project, 'CompoundA')
00772                 
00773                 pA = bd.new( project, cA, 'InputParameters')
00774                 pA.Name = 'InpPar'
00775                 
00776                 project.CommitTransaction()
00777 
00778                 
00779                 # SAVE_AS operation
00780                 # should create a file, and activate that project
00781                 project.Save( "MGA=" + mganame_SavedAs)
00782 
00783                 #
00784                 # ... and create some other kinds in the project, right after the saveAs operation
00785                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00786 
00787                 cB = bd.findInProj( project, 'CompoundB')
00788                 
00789                 sA = bd.new( project, cB, 'InputSignals')
00790                 sA.Name = 'InpSig'
00791                 
00792                 project.CommitTransaction()
00793                 project.Close(0)
00794                 
00795                 # 
00796                 # open and test the saved as project
00797                 project.Open( "MGA=" + mganame_SavedAs)
00798 
00799                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00800 
00801                 cA = bd.findInProj( project, 'CompoundA')
00802                 cB = bd.findInProj( project, 'CompoundB')
00803                 pA = bd.findInProj( project, 'InpPar')
00804                 sA = bd.findInProj( project, 'InpSig')
00805                 
00806                 assert sA
00807                 assert sA.ID
00808                 assert pA
00809                 assert pA.ID
00810                 
00811                 project.CommitTransaction()
00812                 project.Close(0)
00813 
00814                 # 
00815                 # open and test the OLD project
00816                 project.Open( "MGA=" + mganame)
00817 
00818                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00819 
00820                 cA = bd.findInProj( project, 'CompoundA')
00821                 cB = bd.findInProj( project, 'CompoundB')
00822                 assert cA.ID
00823                 assert cB.ID
00824                 
00825                 # 
00826                 # ... should not contain the kind created BEFORE the SaveAs
00827                 try:
00828                         pA = bd.findInProj( project, 'InpPar')
00829                         self.fail("Should have failed")
00830                 except:
00831                         #good, it is expected to fail
00832                         pass
00833                         
00834                 #
00835                 # ... should not contain the kind created AFTER the SaveAs
00836                 try:
00837                         sA = bd.findInProj( project, 'InpSig')
00838                         self.fail("Should have failed")
00839                 except:
00840                         #goood, it is expected to fail
00841                         pass
00842                 
00843                 project.CommitTransaction()
00844                 project.Close(0)
00845 
00846         @dec_disable_early_binding
00847         def testE5( self ):
00848                 """    testE5
00849                 
00850                 SaveAs          under a different name, with "Keep oldname" option
00851                 """
00852                 mganame = _adjacent_file("_tc4_E5_sf.mga")
00853                 mganame_SavedAs = _adjacent_file("_tc4_E5_savedAs_sf.mga")
00854 
00855                 # create the project with the needed kinds
00856                 project = bd.creaP( mganame, "SF")
00857                 if not project:
00858                         self.fail("Create failed")
00859                 try:
00860                         self.populate4E5( project)
00861                 except:
00862                         bd.saveP( project)
00863                         raise
00864                 bd.saveP( project)
00865 
00866                 self.project = project
00867 
00868                 # open the created project
00869                 project.Open( "MGA=" + mganame)
00870 
00871                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00872 
00873                 cA = bd.findInProj( project, 'CompoundA')
00874                 
00875                 pA = bd.new( project, cA, 'InputParameters')
00876                 pA.Name = 'InpPar'
00877                 
00878                 project.CommitTransaction()
00879 
00880                 #
00881                 # SAVE_AS operation and KEEP OLD NAME
00882                 # should create a file, and remain with the project name above
00883                 keep_old_name = True
00884                 project.Save( "MGA=" + mganame_SavedAs, keep_old_name)
00885                 project.Close(0)
00886                 
00887                 #
00888                 # open and test the OLD project
00889                 project.Open( "MGA=" + mganame)
00890                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00891 
00892                 cA = bd.findInProj( project, 'CompoundA')
00893                 pA = bd.findInProj( project, 'InpPar')
00894 
00895                 assert cA.ID            # valid pointer
00896                 assert pA.ID            # valid pointer
00897                 
00898                 project.CommitTransaction()
00899                 project.Close(0)
00900 
00901                 #
00902                 # open and test the SAVEDAS project
00903                 project.Open( "MGA=" + mganame_SavedAs)
00904                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00905 
00906                 cA = bd.findInProj( project, 'CompoundA')
00907                 pA = bd.findInProj( project, 'InpPar')
00908 
00909                 assert cA.ID            # valid pointer
00910                 assert pA.ID            # valid pointer
00911                 
00912                 project.CommitTransaction()
00913                 project.Close(0)
00914 
00915         @dec_disable_early_binding
00916         def testE6( self ):
00917                 """    testE6
00918                 
00919                 SaveAs          under a different name, with "Keep oldname" option
00920                 Apply changes   after the SaveAs operation
00921                 """
00922                 mganame = _adjacent_file("_tc4_E6_sf.mga")
00923                 mganame_SavedAs = _adjacent_file("_tc4_E6_savedAs_sf.mga")
00924 
00925                 # create the project with the needed kinds
00926                 project = bd.creaP( mganame, "SF")
00927                 if not project:
00928                         self.fail("Create failed")
00929                 try:
00930                         self.populate4E6( project)
00931                 except:
00932                         bd.saveP( project)
00933                         raise
00934                 bd.saveP( project)
00935 
00936                 self.project = project
00937 
00938                 # open the created project
00939                 project.Open( "MGA=" + mganame)
00940 
00941                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00942 
00943                 cA = bd.findInProj( project, 'CompoundA')
00944                 
00945                 pA = bd.new( project, cA, 'InputParameters')
00946                 pA.Name = 'InpPar'
00947                 
00948                 project.CommitTransaction()
00949 
00950                 #
00951                 # SAVE_AS operation and KEEP OLD NAME
00952                 # should create a file, and remain with the project name above
00953                 keep_old_name = True
00954                 project.Save( "MGA=" + mganame_SavedAs, keep_old_name)
00955 
00956                 #
00957                 # make some changes right after the SAVEAS operation !!!
00958                 #
00959                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00960 
00961                 cB = bd.findInProj( project, 'CompoundB')
00962                 assert cB.ID
00963                 
00964                 pB = bd.new( project, cB, 'OutputParameters')
00965                 pB.Name = 'OutPar'
00966 
00967                 project.CommitTransaction()
00968                 project.Close(0)
00969 
00970                 #
00971                 # open and test the OLD project
00972                 project.Open( "MGA=" + mganame)
00973                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00974 
00975                 #
00976                 # should contain all kinds created
00977                 #
00978                 cA = bd.findInProj( project, 'CompoundA')
00979                 pA = bd.findInProj( project, 'InpPar')
00980                 pB = bd.findInProj( project, 'OutPar')
00981 
00982                 assert cA.ID            # valid pointer
00983                 assert pA.ID            # valid pointer
00984                 assert pB.ID            # valid pointer
00985                 
00986                 project.CommitTransaction()
00987                 project.Close(0)
00988 
00989                 #
00990                 # open and test the SAVEDAS project
00991                 project.Open( "MGA=" + mganame_SavedAs)
00992                 project.BeginTransaction( project.CreateTerritory( None, None, None))
00993 
00994                 #
00995                 # should contain kinds created BEFORE the SAVEDAS
00996                 #
00997                 cA = bd.findInProj( project, 'CompoundA')
00998                 pA = bd.findInProj( project, 'InpPar')
00999 
01000                 assert cA.ID            # valid pointer
01001                 assert pA.ID            # valid pointer
01002                 
01003                 #
01004                 # should NOT contain kinds created AFTER the SAVEDAS
01005                 #
01006                 try:
01007                         pB = bd.findInProj( project, 'OutPar')
01008                         self.fail("Should have failed")
01009                 except:
01010                         #goood, it is expected to throw
01011                         pass
01012 
01013                 project.CommitTransaction()
01014                 project.Close(0)
01015 
01016 
01017         def populate4F(self, p):
01018                 # will get relid 1
01019                 folder1 = bd.newFolder( p, p.RootFolder, 'Folder')
01020                 folder1.Name = 'FolderA'
01021                 
01022                 # will get relid 2
01023                 folder2 = bd.newFolder( p, p.RootFolder, 'Folder')
01024                 folder2.Name = 'FolderA'
01025                 
01026                 folder2.DestroyObject()
01027 
01028                 # will get relid 3
01029                 folder3 = bd.newFolder( p, p.RootFolder, 'Folder')
01030                 folder3.Name = 'FolderA'
01031 
01032                 compa1 = bd.newObjInFold( p, folder1, 'Compound')
01033                 compa1.Name = 'CompoundA'
01034                 
01035                 compa2 = bd.newObjInFold( p, folder3, 'Compound')
01036                 compa2.Name = 'CompoundA'
01037 
01038                 compb  = bd.newObjInFold( p, folder3, 'Compound')
01039                 compb.Name = 'CompoundC'
01040 
01041         def testF( self ):
01042 
01043                 """    testF
01044 
01045                 ObjectByPath            invoked with #relids
01046                                         invoked with @name|kind strings
01047                                                         -for unique object
01048                                                         -for non-unique object
01049                                                         -for non-existing object
01050                                         invoked with name|kind|relpos string
01051 
01052                 NthObjectByPath         invoked with name|kind|relpos string
01053                                                         -for unique object
01054                                                         -for non-unique object
01055                                                         -for non-existing object
01056 
01057                 """
01058                 
01059                 mganame = _adjacent_file("_tc4_F_sf.mga")
01060                 # create the project with the needed kinds
01061                 project = bd.creaP( mganame, "SF")
01062                 if not project:
01063                         self.fail("Create failed")
01064                 try:
01065                         self.populate4F( project)
01066                 except:
01067                         bd.saveP( project)
01068                         raise
01069                 bd.saveP( project)
01070 
01071                 self.project = project
01072 
01073                 # open the created project
01074                 ro = project.Open( "MGA=" + mganame)
01075                 assert not ro
01076                 
01077                 tran = project.BeginTransaction( project.CreateTerritory( None, None, None))
01078                 
01079                 # search based on relid path
01080                 fco = project.ObjectByPath( "#1/#1" )
01081                 assert fco.Name == "CompoundA"
01082                 fco = project.ObjectByPath( "#3/#1" )
01083                 assert fco.Name == "CompoundA"
01084                 fco = project.ObjectByPath( "#3/#2" )
01085                 assert fco.Name == "CompoundC"
01086                 
01087                 fol = project.ObjectByPath( "#3" )
01088                 assert fol.Name == "FolderA"
01089                 
01090                 # find a unique object
01091                 fco = project.ObjectByPath( "@FolderA|kind=Folder/@CompoundC|kind=Compound")
01092                 assert fco.Name == "CompoundC"
01093 
01094                 # ... find the same object with ignored relpos indicators
01095                 fco = project.ObjectByPath( "@FolderA|kind=Folder|relpos=0/@CompoundC|kind=Compound|relpos=1")
01096                 assert fco.Name == "CompoundC"
01097                 
01098                 # ... find the same (unique) object with misleading relpos indicators and NthObjectByPath
01099                 fco = project.NthObjectByPath( 0, "@FolderA|kind=Folder|relpos=11/@CompoundC|kind=Compound|relpos=22")
01100                 assert fco.Name == "CompoundC"
01101                 
01102                 # try a non-unique object search
01103                 try:
01104                         fco = project.ObjectByPath( "@FolderA|kind=Folder/@CompoundA|kind=Compound")
01105                         # fco is (must be) 0, so let's provoke an error
01106                         s_dummy = fco.Name
01107                         # the prev line should have raised an exception
01108                         assert 0
01109                 except AttributeError:
01110                         # Goood, since the fco is null
01111                         assert 1
01112                         
01113                         # now try the NthObjectByPath for this
01114                         fco = project.NthObjectByPath( 0, "@FolderA|kind=Folder|relpos=1/@CompoundA|kind=Compound|relpos=1")
01115                         assert fco.Name == "CompoundA"
01116                 except:
01117                         # other error
01118                         assert 0
01119                 
01120                 # try a no result search with ObjectByPath
01121                 try:
01122                         fco = project.ObjectByPath( "@FolderA|kind=Folder|relpos=1/@CompoundX|kind=Compound|relpos=1")
01123                         s_dummy = fco.Name
01124                         # the prev line should have raised an exception
01125                         assert 0
01126                 except AttributeError:
01127                         # Goood, since the fco must be null
01128                         assert 1
01129                 except:
01130                         # other error
01131                         assert 0
01132                 
01133                 # ... and with NthObjectByPath
01134                 try:
01135                         fco = project.NthObjectByPath( 0, "@FolderA|kind=Folder|relpos=1/@CompoundX|kind=Compound|relpos=1")
01136                         s_dummy = fco.Name
01137                         # the prev line should have raised an exception
01138                         assert 0
01139                 except AttributeError:
01140                         # Goood, since the fco must be null
01141                         assert 1
01142                 except:
01143                         # other error
01144                         assert 0
01145 
01146                 project.CommitTransaction()
01147                 project.Close(0)
01148                 pass
01149                 
01150         def populate4G(self, p):
01151                 p.RootFolder.Name = '_tc4_G_sf'
01152 
01153                 # will get id 'id-006a-00000002'
01154                 folder1 = bd.newFolder( p, p.RootFolder, 'Folder')
01155                 folder1.Name = 'FolderA'
01156                 
01157                 # will get id 'id-006a-00000003'
01158                 folder2 = bd.newFolder( p, p.RootFolder, 'Folder')
01159                 folder2.Name = 'FolderB'
01160                 
01161                 # will get id 'id-0065-00000001'
01162                 comp1 = bd.newObjInFold( p, folder1, 'Compound')
01163                 comp1.Name = 'Compound1'
01164                 
01165                 # will get id 'id-0065-00000002'
01166                 prim1 = bd.newObjInFold( p, folder2, 'Primitive')
01167                 prim1.Name = 'Primitive1'
01168                 
01169                 # will get id 'id-0065-00000003'
01170                 comppA  = bd.new( p, comp1, 'CompoundParts')
01171                 comppA.Name = 'CompoundPartsA'
01172                 
01173                 # will get id 'id-0065-00000004'
01174                 primpA  = bd.new( p, comp1, 'PrimitiveParts')
01175                 primpA.Name = 'PrimitivePartsA'
01176                 
01177                 # will get id 'id-0066-00000001'
01178                 ip = bd.new( p, comppA, 'InputParameters')
01179                 ip.Name = 'InputParameterP'
01180                 
01181                 # will get id 'id-0066-00000002'
01182                 os = bd.new( p, comppA, 'OutputSignals')
01183                 os.Name = 'OutputSignalQ'
01184         
01185         @dec_disable_early_binding
01186         def testG( self ):
01187 
01188                 """    testG
01189 
01190                 GetObjectByID
01191 
01192                 """
01193 
01194                 mganame = _adjacent_file("_tc4_G_sf.mga")
01195                 # create the project with the needed kinds
01196                 project = bd.creaP( mganame, "SF")
01197                 if not project:
01198                         self.fail("Create failed")
01199                 try:
01200                         self.populate4G( project)
01201                 except:
01202                         bd.saveP( project)
01203                         raise
01204                 bd.saveP( project)
01205 
01206                 self.project = project
01207 
01208                 # open the created project
01209                 ro = project.Open( "MGA=" + mganame )
01210                 assert not ro
01211                 
01212                 tran = project.BeginTransaction( project.CreateTerritory( None, None, None))
01213                 
01214                 # search based on id
01215                 to_find = "id-006a-00000001"
01216                 obj = project.GetObjectByID( to_find )
01217                 assert obj.ID   == to_find
01218                 assert obj.Name == "_tc4_G_sf"          # rootfolder
01219                 assert obj.RelID == 1
01220                 
01221                 to_find = "id-006a-00000002"
01222                 obj = project.GetObjectByID( to_find )
01223                 assert obj.ID   == to_find
01224                 assert obj.Name == "FolderA"
01225                 assert obj.RelID == 1
01226 
01227                 to_find = "id-006a-00000003"
01228                 obj = project.GetObjectByID( to_find )
01229                 assert obj.ID   == to_find
01230                 assert obj.Name == "FolderB"
01231                 assert obj.RelID == 2
01232 
01233                 to_find = "id-0065-00000001"
01234                 obj = project.GetObjectByID( to_find )
01235                 assert obj.ID   == to_find
01236                 assert obj.Name == "Compound1"
01237                 assert obj.RelID == 1
01238                 
01239                 to_find = "id-0065-00000002"
01240                 obj = project.GetObjectByID( to_find )
01241                 assert obj.ID   == to_find
01242                 assert obj.Name == "Primitive1"
01243                 assert obj.RelID == 1
01244                 
01245                 to_find = "id-0065-00000003"
01246                 obj = project.GetObjectByID( to_find )
01247                 assert obj.ID   == to_find
01248                 assert obj.Name == "CompoundPartsA"
01249                 assert obj.RelID == 1
01250 
01251                 to_find = "id-0065-00000004"
01252                 obj = project.GetObjectByID( to_find )
01253                 assert obj.ID   == to_find
01254                 assert obj.Name == "PrimitivePartsA"
01255                 assert obj.RelID == 2
01256                 
01257                 to_find = "id-0066-00000001"
01258                 obj = project.GetObjectByID( to_find )
01259                 assert obj.ID   == to_find
01260                 assert obj.Name == "InputParameterP"
01261                 assert obj.RelID == 1
01262 
01263                 to_find = "id-0066-00000002"
01264                 obj = project.GetObjectByID( to_find )
01265                 assert obj.ID   == to_find
01266                 assert obj.Name == "OutputSignalQ"
01267                 assert obj.RelID == 2
01268 
01269                 project.CommitTransaction()
01270                 project.Close(0)
01271                 pass
01272 
01273         def populate4H(self, p):
01274                 p.RootFolder.Name = '_tc4_H_sf'
01275 
01276                 # will get id 'id-006a-00000002'
01277                 folder1 = bd.newFolder( p, p.RootFolder, 'Folder')
01278                 folder1.Name = 'FolderA'
01279                 
01280                 # will get id 'id-006a-00000003'
01281                 folder2 = bd.newFolder( p, p.RootFolder, 'Folder')
01282                 folder2.Name = 'FolderA'
01283                 
01284                 # will get id 'id-0065-00000001'
01285                 comp1 = bd.newObjInFold( p, folder1, 'Compound')
01286                 comp1.Name = 'Compound1'
01287                 
01288                 # will get id 'id-0065-00000002'
01289                 prim1 = bd.newObjInFold( p, folder2, 'Primitive')
01290                 prim1.Name = 'Primitive1'
01291                 
01292                 # will get id 'id-0065-00000003'
01293                 comppA  = bd.new( p, comp1, 'CompoundParts')
01294                 comppA.Name = 'CompoundPartsA'
01295                 
01296                 # will get id 'id-0065-00000004'
01297                 primpA  = bd.new( p, comp1, 'PrimitiveParts')
01298                 primpA.Name = 'PrimitivePartsA'
01299                 
01300                 # will get id 'id-0066-00000001'
01301                 ip = bd.new( p, comppA, 'InputParameters')
01302                 ip.Name = 'InputParameterP'
01303                 
01304                 # will get id 'id-0066-00000002'
01305                 os = bd.new( p, comppA, 'OutputSignals')
01306                 os.Name = 'OutputSignalQ'
01307         
01308         @dec_disable_early_binding
01309         def testH( self ):
01310 
01311                 """    testH
01312 
01313                 GetFCOByID      for folder (expecting 0)
01314                                 for fcos
01315 
01316                 """
01317 
01318                 mganame = _adjacent_file("_tc4_H_sf.mga")
01319                 # create the project with the needed kinds
01320                 project = bd.creaP( mganame, "SF")
01321                 if not project:
01322                         self.fail("Create failed")
01323                 try:
01324                         self.populate4H( project)
01325                 except:
01326                         bd.saveP( project)
01327                         raise
01328                 bd.saveP( project)
01329 
01330                 self.project = project
01331 
01332                 # open the created project
01333                 ro = project.Open( "MGA=" + mganame )
01334                 assert not ro
01335                 
01336                 tran = project.BeginTransaction( project.CreateTerritory( None, None, None))
01337                 
01338                 # search based on id
01339                 # for a folder
01340                 to_find = "id-006a-00000002"
01341                 try:
01342                         fco = project.GetFCOByID( to_find )
01343                         assert fco.ID   == to_find
01344                         assert fco.Name == "FolderA"
01345                         assert fco.RelID == 1
01346                         # this is wrong, fco should be 0, exception should have thrown
01347                         assert 0
01348                 except AttributeError:
01349                         # goood, the GetFCOByID should not return a valid folder
01350                         assert 1
01351                 except:
01352                         assert 1
01353                 
01354                 # for FCOs
01355                 to_find = "id-0065-00000001"
01356                 fco = project.GetFCOByID( to_find )
01357                 assert fco.ID   == to_find
01358                 assert fco.Name == "Compound1"
01359                 assert fco.RelID == 1
01360                 
01361                 to_find = "id-0065-00000002"
01362                 fco = project.GetFCOByID( to_find )
01363                 assert fco.ID   == to_find
01364                 assert fco.Name == "Primitive1"
01365                 assert fco.RelID == 1
01366                 
01367                 to_find = "id-0065-00000003"
01368                 fco = project.GetFCOByID( to_find )
01369                 assert fco.ID   == to_find
01370                 assert fco.Name == "CompoundPartsA"
01371                 assert fco.RelID == 1
01372 
01373                 to_find = "id-0065-00000004"
01374                 fco = project.GetFCOByID( to_find )
01375                 assert fco.ID   == to_find
01376                 assert fco.Name == "PrimitivePartsA"
01377                 assert fco.RelID == 2
01378                 
01379                 to_find = "id-0066-00000001"
01380                 fco = project.GetFCOByID( to_find )
01381                 assert fco.ID   == to_find
01382                 assert fco.Name == "InputParameterP"
01383                 assert fco.RelID == 1
01384 
01385                 to_find = "id-0066-00000002"
01386                 fco = project.GetFCOByID( to_find )
01387                 assert fco.ID   == to_find
01388                 assert fco.Name == "OutputSignalQ"
01389                 assert fco.RelID == 2
01390 
01391                 project.CommitTransaction()
01392                 project.Close(0)
01393                 pass
01394 
01395         def populate4I(self, p):
01396                 pass
01397         def testI( self ):
01398 
01399                 """   testI
01400 
01401                 BeginTransaction
01402                 GetFCOsByName           TODO: implement the feature first, then the testcase
01403                 GetFolderByPath         TODO: implement the feature first, then the testcase
01404                 AbortTransaction
01405 
01406                 """
01407 
01408                 mganame = _adjacent_file("_tc4_I_sf.mga")
01409                 # create the project with the needed kinds
01410                 project = bd.creaP( mganame, "SF")
01411                 if not project:
01412                         self.fail("Create failed")
01413                 try:
01414                         self.populate4I( project)
01415                 except:
01416                         bd.saveP( project)
01417                         raise
01418                 bd.saveP( project)
01419 
01420                 self.project = project
01421 
01422                 # open the created project
01423                 ro = project.Open( "MGA=" + mganame )
01424                 assert not ro
01425                 
01426                 tran = project.BeginTransaction( project.CreateTerritory( None, None, None))
01427                 
01428                 # GetFCOsByName
01429                 to_find = "Anything"
01430                 try:
01431                         fco = project.GetFCOsByName( to_find )
01432                         # this is wrong, fco should be 0, exception should have thrown
01433                         assert 0
01434                 except:
01435                         # goood, since the GetFCOsByName is not implemented yet (develop the test case if available)
01436                         assert 1
01437 
01438                 # GetFolderByPath
01439                 to_find = "Anything"
01440                 try:
01441                         fol = project.GetFolderByPath( to_find )
01442                         # this is wrong, fol should be 0, exception should have thrown
01443                         assert 0
01444                 except:
01445                         # goood, since the GetFolderByPath is not implemented yet (develop the test case if available)
01446                         assert 1
01447 
01448                 project.AbortTransaction()
01449                 project.Close(0)
01450                 pass
01451                 
01452         def populate4J(self, p):
01453                 compM1 = bd.newObjInFold( p, p.RootFolder, 'Compound')
01454                 compM1.Name = 'CompoundM'
01455                 compM2 = bd.newObjInFold( p, p.RootFolder, 'Compound')
01456                 compM2.Name = 'CompoundM'
01457 
01458                 folder1 = bd.newFolder( p, p.RootFolder, 'Folder')
01459                 folder1.Name = 'FolderA'
01460 
01461                 compA1 = bd.newObjInFold( p, folder1, 'Compound')
01462                 compA1.Name = 'CompoundA'
01463                 
01464                 compA2 = bd.newObjInFold( p, folder1, 'Compound')
01465                 compA2.Name = 'CompoundA'
01466                 
01467                 pp1  = bd.new( p, compA1, 'CompoundParts')
01468                 pp1.Name = 'NewCompoundParts'
01469                 
01470                 pp2  = bd.new( p, compA1, 'CompoundParts')
01471                 pp2.Name = 'NewCompoundParts'
01472                 
01473                 
01474                 ip1 = bd.new( p, compA2, 'InputParameters')
01475                 ip1.Name = 'NewInputParameters'
01476                 ip2 = bd.new( p, compA2, 'InputParameters')
01477                 ip2.Name = 'NewInputParameters'
01478                 
01479 
01480         @dec_disable_early_binding
01481         def testJ( self ):
01482                 """   testJ
01483 
01484                 BeginTransaction
01485                 CreateFilter                    
01486                 AllFCOs                         inquire all objects with an empty filter
01487                 change filter
01488                 AllFCOs                         inquire some objects with a constrained filter
01489                 CommitTransaction
01490 
01491                 """
01492 
01493                 mganame = _adjacent_file("_tc4_J_sf.mga")
01494                 # create the project with the needed kinds
01495                 project = bd.creaP( mganame, "SF")
01496                 if not project:
01497                         self.fail("Create failed")
01498                 try:
01499                         self.populate4J( project)
01500                 except:
01501                         bd.saveP( project)
01502                         raise
01503                 bd.saveP( project)
01504 
01505                 self.project = project
01506 
01507                 # open the created project
01508                 ro = project.Open( "MGA=" + mganame )
01509                 assert not ro
01510                 
01511                 tran = project.BeginTransaction( project.CreateTerritory( None, None, None))
01512 
01513                 # create a filter
01514                 filter = project.CreateFilter()
01515                 
01516                 # use an empty filter
01517                 all_fcos = project.AllFCOs( filter )
01518 
01519                 all_names = []
01520                 for f in all_fcos: all_names.append( f.Name )
01521 
01522                 res = [ "CompoundA", "CompoundA", "CompoundM", "CompoundM", \
01523                 "NewCompoundParts", "NewCompoundParts", "NewInputParameters", "NewInputParameters" ]
01524 
01525                 all_names.sort()
01526                 res.sort()
01527 
01528                 assert 2 == all_names.count( "CompoundA" )
01529                 assert 2 == all_names.count( "CompoundM" )
01530                 assert 2 == all_names.count( "NewCompoundParts" )
01531                 assert 2 == all_names.count( "NewInputParameters" )
01532                 assert 8 == all_fcos.Count
01533                 assert res == all_names         # sorted lists
01534 
01535 
01536                 # use Name filter
01537                 filter.Name = "CompoundM"
01538                 some_fcos = project.AllFCOs( filter )
01539 
01540                 namelist = []
01541                 for f in some_fcos: namelist.append( f.Name )
01542 
01543                 assert 2 == namelist.count( "CompoundM" )
01544                 assert 2 == some_fcos.Count
01545                 
01546                 # use Kind filter #1
01547                 filter.Name = ""                # reset Name filter value
01548                 filter.Kind = "InputParam"
01549 
01550                 some_fcos = project.AllFCOs( filter )
01551                 namelist = []
01552                 for f in some_fcos: namelist.append( f.Name )
01553 
01554                 assert 2 == namelist.count( "NewInputParameters" )
01555                 assert 2 == some_fcos.Count
01556 
01557                 # use Kind filter #2
01558                 filter.Kind = "Compound"
01559 
01560                 some_fcos = project.AllFCOs( filter )
01561 
01562                 namelist = []
01563                 for f in some_fcos: namelist.append( f.Name )
01564 
01565                 assert 2 == namelist.count( "NewCompoundParts" )
01566                 assert 2 == namelist.count( "CompoundA" )
01567                 assert 2 == namelist.count( "CompoundM" )
01568                 assert 6 == some_fcos.Count
01569 
01570                 # use Role filter
01571                 filter.Kind = ""                # reset Kind filter value
01572                 filter.Role = "CompoundParts"
01573 
01574                 some_fcos = project.AllFCOs( filter )
01575 
01576                 namelist = []
01577                 for f in some_fcos: namelist.append( f.Name )
01578 
01579                 assert 2 == namelist.count( "NewCompoundParts" )
01580                 assert 2 == some_fcos.Count
01581 
01582                 # use ObjType filter
01583                 filter.Role = ""                # reset Role filter value
01584                 filter.ObjType = "OBJTYPE_ATOM"
01585 
01586                 some_fcos = project.AllFCOs( filter )
01587 
01588                 namelist = []
01589                 for f in some_fcos: namelist.append( f.Name )
01590 
01591                 assert 2 == namelist.count( "NewInputParameters" )
01592                 assert 2 == some_fcos.Count
01593 
01594 
01595                 # use Level filter #1
01596                 filter.ObjType = ""             # reset ObjType filter value
01597                 filter.Level = 0
01598 
01599                 some_fcos = project.AllFCOs( filter )
01600 
01601                 namelist = []
01602                 for f in some_fcos: namelist.append( f.Name )
01603 
01604                 assert 2 == namelist.count( "CompoundA" )
01605                 assert 2 == namelist.count( "CompoundM" )
01606                 assert 4 == some_fcos.Count
01607 
01608                 # use Level filter #2
01609                 filter.Level = 1
01610 
01611                 some_fcos = project.AllFCOs( filter )
01612 
01613                 namelist = []
01614                 for f in some_fcos: namelist.append( f.Name )
01615 
01616                 assert 2 == namelist.count( "NewCompoundParts" )
01617                 assert 2 == namelist.count( "NewInputParameters" )
01618                 assert 4 == some_fcos.Count
01619 
01620                 # test Project property of the filter
01621                 assert f.Project == project
01622                 
01623                 project.CommitTransaction()
01624                 project.Close(0)
01625                 pass
01626 
01627 
01628 """
01629         Let's produce the test suites
01630 """
01631 def suites():
01632         suite = unittest.makeSuite(TestCase4,'test')
01633         return suite
01634 
01635 def suites3():
01636         suite = unittest.TestSuite()
01637         suite.addTest( TestCase4( "testA"))
01638         suite.addTest( TestCase4( "testB"))
01639         suite.addTest( TestCase4( "testC"))
01640         suite.addTest( TestCase4( "testD"))
01641         suite.addTest( TestCase4( "testE"))
01642         suite.addTest( TestCase4( "testF"))
01643         suite.addTest( TestCase4( "testG"))
01644         suite.addTest( TestCase4( "testH"))
01645         suite.addTest( TestCase4( "testI"))
01646         suite.addTest( TestCase4( "testJ"))
01647         return suite
01648 
01649 ########
01650 # main
01651 ########
01652 if __name__ == "__main__":
01653         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01654         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01655         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01656         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01657         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01658         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ TEST BEGINS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01659         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01660         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01661         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01662         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01663         print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
01664         
01665         ######## 1st way
01666         unittest.main()
01667 
01668         ######## 2nd way
01669         # unittest.main(defaultTest='TestCase4')
01670         
01671         ######## 3rd way
01672         # all = suites3()
01673         # runner = unittest.TextTestRunner()
01674         # runner.run( all )