[Pymerase-cvs-commit] smw/smw/scw/Project/unittests init.py,NONE,1.1 testSfiManager.py,NONE,1.1

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/pymerase/smw/smw/scw/Project/unittests
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/scw/Project/unittests

Added Files:
	__init__.py testSfiManager.py 
Log Message:
Imported version of SMW downloaded on 2003 Apr 14

--- NEW FILE: __init__.py ---
__all__ = ['testSfiManager']
from testSfiManager import *

--- NEW FILE: testSfiManager.py ---
#!/usr/bin/env python2

__layer__ = 'Project'

import unittest
from smw.metamodel import UML14 as metamodel
#from LayerManager import LayerManager
from smw.scw.Project.SfiManager import SfiManager
import tempfile
import time
import os.path

def mkUniqueStr():
    """really unique string"""
    s = str(tempfile.mktemp()) + str(time.time())
    s = s.replace('/', '')
    s = s.replace('.', '')
    s = s.replace('@', '')
    return s

def removeFiles(fnames):
    """ Deletes the files with the name added into the fnames array. """
    for n in fnames:
        if os.path.isfile(n):
            try:
                os.remove(n)
            except:
                pass

class testSfiManager(unittest.TestCase):

    def setUp(self):

        self.sMan=obj2test
        self.sMan.setUp()

    def testDeleteProject(self):
        "Testing the delete function in SfiManager"
        # testing with a correct case:
        self.sMan.setUp()
        name=mkUniqueStr()

        p=self.sMan.newProject(name)
        self.assert_(p,"Project was created.")
        self.assert_(self.sMan.currentProject()==p,"Wrong current project.")
        rv=self.sMan.deleteProject(p.name)
        self.assert_(rv==p,"Wrong return value from the function.")
        self.assert_(self.sMan.currentProject()==None,"Wrong current project.")
        self.assert_(not self.sMan.projects().has_key(p.name),"Failed to remove the project from the dict.")

        # testing with invalid parameters (with a project):
        self.sMan.setUp()
        name=mkUniqueStr()
        p=self.sMan.newProject(name)
        ivalues=[None, mkUniqueStr(), metamodel.Model()]
        for iv in ivalues:
            rv=self.sMan.deleteProject(iv)
            self.assert_(not rv,"Wrong return value.")
            self.assert_(self.sMan.currentProject()==p,"Incorrect current project.")

        # testing with invalid parameters (without a project):
        self.sMan.setUp()
        ivalues=[None, mkUniqueStr(), metamodel.Model()]
        for iv in ivalues:
            rv=self.sMan.deleteProject(iv)
            self.assert_(not rv,"Wrong return value.")
            self.assert_(self.sMan.currentProject()==None,"Incorrect current project.")

  ##      self.sMan.newProject('name2')

##        origLength=len(self.sMan.projects().keys())
##        self.sMan.deleteProject('name1')
##        self.failIf(self.sMan.projects().has_key('name1'),"Deleting in SwfiManager unsuccesfull(1)")
##        length=len(self.sMan.projects().keys())
##        self.assertEqual((length+1),origLength,"Deleting in SwfiManager unsuccesfull(2)")        

##        name='name3'

##        self.sMan.newProject(name)
##        m=self.sMan.projects()[name]
##        uModel1  = self.sMan.deleteProject(name)

##        self.assert_(uModel1 == m, "deleteProject did not return the project.") 

##        uModel2 = self.sMan.deleteProject(name)# This should fail
##        self.assert_(uModel2==None, "None-value was not returned.")

##        # Test that current element is deleted.
##        self.sMan.setUp()
##        proj1=self.sMan.newProject("Project1")
##        #self.sMan.newClass()
##        proj2=self.sMan.newProject("Project2")
##        #self.sMan.newClass()

##        current=self.sMan.currentProject()
##        self.sMan.deleteProject(self.sMan.currentProject().name)
##        self.assertEqual(self.sMan.currentProject(),proj1,"wrong current project after deleting project")
##        self.assertNotEqual(self.sMan.currentProject(),current,"The current element was deleted")
##       ## # testing delete the namespace of the python package
##        self.sMan.setUp()
##        p1=self.sMan.newProject()
##        self.assert_(p1,"project was not created")
##        p2=self.sMan.newProject()
##        self.assert_(p2,"project was not created")
##        self.assertEqual(self.sMan.pythonPackage().namespace,p2,"wrong namespace")
##        self.assertEqual(self.sMan.currentProject(),p2,"wrong current project")
##        rv=self.sMan.deleteProject(p2.name)
##        self.assertEqual(p2,rv,"wrong return value")
##        self.assertEqual(self.sMan.currentProject(),p1,"wrong current project after delete")
##        self.assertEqual(self.sMan.pythonPackage().namespace,p1,"namespace should have changed")

        # test deleting a project with the project as parameter
        self.sMan.setUp()
        for p in range(3):
            proj=self.sMan.newProject()
            len1=len(self.sMan.projects())
            pr=self.sMan.deleteProject(proj)
            len2=len(self.sMan.projects())
            self.assert_(len1==len2+1,"didn't delete the project")
            self.assert_(pr==proj,"didn't delete the project")

    def testRenameProject(self):
        "Testing the rename function in SwfiManager."
        self.sMan.setUp()
        name=mkUniqueStr()
        N=10
        p=self.sMan.newProject(name)
        self.assert_(p,"project was not created.")
        for x in range(N):
            uname=mkUniqueStr()

            n=self.sMan.renameProject(self.sMan.currentProject().name,uname)
            self.assert_(n==uname,"Wrong return value.")
            self.assert_(self.sMan.currentProject().name==n,"Wrong name for the project.")
            self.assert_(self.sMan.currentProject()==p,"Wrong current project.")

        # Testing for invalid values:
        name=mkUniqueStr()
        rv=self.sMan.renameProject(self.sMan.currentProject().name,name)
        self.assert_(rv==name,"Wrong name.")
        invalidValues=["in.valid.name", None, "", name]    
        for iv in invalidValues:
            rv=self.sMan.renameProject(self.sMan.currentProject().name,iv)
            self.assert_(rv==None,"None should be returned.")
            self.assert_(self.sMan.currentProject()==p,"Wrong current project.")
            self.assert_(self.sMan.currentProject().name==name,"Name was changed.")

##        self.sMan.setUp()

##        oldName="name3"
##        newName="name4"        

##        oldName1="name5"
##        newName1="name6"

##        self.sMan.newProject(oldName)

##        m=self.sMan.projects()[oldName]
##        self.sMan.renameProject(oldName,newName)  

##        self.assertEqual(self.sMan.projects()[newName],m,"Renaming in SwfiManager unsuccesfull(1)")
##        self.failIf(self.sMan.projects().has_key(oldName),"Renaming in SwfiManager unsuccesfull(2)")
##        self.assertEqual(self.sMan.projects()[newName].name,newName,"Error in updating the renaming to umlModel")

##        rName = self.sMan.renameProject(oldName, newName)# Trying to rename oldname again. this should fail.
##        self.assert_(rName == None,"Renaming function did not return 'None' when it failed. ")

##        self.setUp()
##        self.sMan.newProject(oldName1)
##        rName = self.sMan.renameProject(oldName1, newName1)# Trying rename correctly.
##        self.assert_(rName == newName1,"Renaming function did not return the correct name")

##        #self.sMan.newProject("returnTest")
##        #self.sMan.newProject("returnTest1")
##        #testi=self.sMan.renameProject(oldName1,newName1)# Trying to give an existing name.
##        #self.assertEqual(testi,None,"Failure in renaming: None not received")

##        #testing renaming with invalid new names

##        #self.sMan.newProject("temp")
##        testi=self.sMan.renameProject("returnTest","invalid.1")
##        self.assertEqual(testi,None,"Was able to rename project with invalid name")

    def test__init__(self):
        "Testing the initialization of SwfiManager"

        self.sMan.setUp()

        self.assertNotEqual(self.sMan, None,'The creation of an object was not succesful.')
        self.assertEqual(self.sMan.projects(), {}, 'Dictionary was not initialized')

    def testNewProject(self):
        "Testing the NewProject-method"
        # Make sure that it is impossible to create multiple projects.

        N=10
        self.sMan.setUp()
        p=self.sMan.newProject()
        self.assert_(p, "Project was not created.")
        self.assert_(self.sMan.currentProject()==p,"Wrong current project.")
        for x in range(N):
            pn=self.sMan.newProject()
            self.assert_(not pn, "Project p2 was not created.")
            self.assert_(self.sMan.currentProject()==p,"Wrong current project.")

        self.sMan.setUp()

        length=len(self.sMan.projects())
        self.sMan.newProject("NewProject1")
        self.assertEqual(len(self.sMan.projects()),length+1,"The new project was not inserted.")
        self.assert_(self.sMan.projects().has_key("NewProject1"),  "The method did't create an appropriate key.")
        #testing with different paramter sets
        cvalues=[mkUniqueStr(),"",None]

        for v in cvalues:
            self.sMan.setUp()
            pn=self.sMan.newProject()
            self.assert_(pn, "Project pn was not created.")
            self.assert_(self.sMan.currentProject()==pn,"Wrong current project.")
        #testing with invalid paramter sets:
        self.sMan.setUp()
        p=self.sMan.newProject()
        self.assert_(p, "Project was not created.")
        self.assert_(self.sMan.currentProject()==p,"Wrong current project.")

        ivalues=["in.valid.name",metamodel.Package()]
        for iv in ivalues:

            self.sMan.setUp()
            rv=self.sMan.newProject(iv)

            self.assert_(not rv,' %s None should be returned.' % iv)
            self.assert_(None==self.sMan.currentProject(),"Wrong current project.")

    def testPythonPackage(self):
        self.sMan.setUp()
        self.assert_(not self.sMan.pythonPackage(),'should be no python package')
        p=self.sMan.newProject()
        self.assert_(p,'project was not created')
        py=self.sMan.pythonPackage()
        self.assert_(py,'No python package')
        found=None
        for o in p.ownedElement:
            if o.name=='python2_2':
                found =1
        self.assert_(found,'python package not found')
        # testing that the package object does not change when trying to create more projects than one
        N=10
        for x in range(N):
            pr=self.sMan.newProject()
            self.assert_(not pr,'more projects than one')
            self.assertEqual(self.sMan.pythonPackage(),py,'object changed')

##        length=len(self.sMan.projects())
##        self.sMan.newProject()
##        self.assertEqual(len(self.sMan.projects()),length+1,"The new project without name was not inserted")

##        self.sMan.setUp()

##        for x in range(3):
##            self.sMan.newProject()

##        keys=self.sMan.projects().keys()

##        self.assertEqual(len(keys),3,"Failure in newProject: two or more projects with the same name(1)")

##        for key in keys[1:]:
##            self.sMan.deleteProject(key)

##        for x in range(3):
##            self.sMan.newProject()

##        keys=self.sMan.projects().keys()

##        self.assertEqual(len(keys),4,"Failure in newProject: two or more projects with the same name(2)")

##        self.sMan.newProject('addedName')
##        test2=self.sMan.newProject('addedName')
##        self.assertEqual(test2,None,"Failure in newProject: adding already existing name failed")

##        length=len(self.sMan.projects())
##        test3=self.sMan.newProject('another')

##        if (test3!=None):
##            self.assertEqual(len(self.sMan.projects()),length+1,"Failure in newProject: count doesn't match")

##        name = 'qwewqeqwe'
##        self.assert_(self.sMan.newProject(name), 'failed to create a project')
##        self.assert_(not self.sMan.newProject(name), 'project with the same name created twice')

##        #testing creating a new project with invalid name

##        test=self.sMan.newProject("invalid-1")
##        self.assertEqual(test,None,"Was able to create a new project with invalid name")

    def testCurrentProject(self):

        self.sMan.setUp()
        #test with an empty sman:
        self.assert_(self.sMan.currentProject()==None,"wrong current project.")
        #test with a project
        p=self.sMan.newProject(mkUniqueStr())
        self.assert_(p, "project was not created.")
        self.assert_(self.sMan.currentProject()==p, "Wrong current project.")

##        self.assertEqual(self.sMan.currentProject(), None, "The value of attribute was not None.")

##        self.sMan.newProject("Project1")
##        self.sMan.newProject("Project2")

##        self.assertNotEqual(self.sMan.currentProject(), None, "After the addition the reference shouldn't be None.")

##        # Delete the model that is currently referenced.

##        deletedModel=self.sMan.deleteProject(self.sMan.currentProject().name)
##        self.assertNotEqual(self.sMan.currentProject(), None, "There is a model left, so the value of the attribute shouldn't be None.")
##        self.assertNotEqual(deletedModel.name,self.sMan.currentProject().name,"The reference should have changed.")

##        self.sMan.deleteProject(self.sMan.currentProject().name)
##        self.assertEqual(self.sMan.currentProject(), None, "The last model was deleted, so the reference should be none")

    def testFocusOnProject(self):

        #testing the focus changing using string as parameter

        self.sMan.setUp()
        name=mkUniqueStr()
        p=self.sMan.newProject(name)
        self.assert_(p,"Project was not created.")
        self.assert_(p==self.sMan.currentProject(),"Wrong current project.")
        rv=self.sMan.focusOnProject(name)
        self.assert_(rv==p, "Wrong returnvalue.") 
        self.assert_(p==self.sMan.currentProject(),"Wrong current project.")
        # Focus using a project object:
        rv=self.sMan.focusOnProject(p)
        self.assert_(rv==p, "Wrong returnvalue.") 
        self.assert_(p==self.sMan.currentProject(),"Wrong current project.")

        # Testing with invalid values:
        self.sMan.setUp()
        ivalues=[metamodel.Model(), None]
        for iv in ivalues:
            rv=self.sMan.focusOnProject(iv)
            self.assert_(not rv, '%s parameter should return None' % iv)
            self.assert_(None==self.sMan.currentProject(),"Wrong current project.")

 ##       self.sMan.setUp()

##        anotherModelName=""

##        self.sMan.newProject("Project1")
##        #self.sMan.newProject("Project2")

##        currentModelName=self.sMan.currentProject().name
##        if(currentModelName=="Project1"):
##            anotherModelName="Project2"
##        elif(currentModelName=="Project2"):
##            anotherModelName="Project1"
##        else:
##            self.assertNotEqual(0,0,"Something has gone VERY wrong!!!")

##        #self.sMan.focusOnProject(anotherModelName)
##        #self.assertEqual(self.sMan.currentProject().name,anotherModelName,"Failed to change focus to another model(1)")

        #testing the focus changing using Model object as parameter

        #changing the test attributes to describe the current situation
 ##       currentModelName,anotherModelName=anotherModelName,currentModelName

##        anotherModel=self.sMan.projects()[anotherModelName]
##        self.sMan.focusOnProject(anotherModel)
##        self.assertEqual(self.sMan.currentProject().name,anotherModel.name,"Failed to change focus to another model(2)")

##        #testing the return value of the method
##        self.sMan.setUp()
##        test=self.sMan.focusOnProject("testing")
##        self.assertEqual(test,None,"was able to focus on nonexistent project")

##        project1=self.sMan.newProject("newProject1")
##        project2=self.sMan.newProject("newProject2")

##        test=self.sMan.focusOnProject("newProject1")
##        self.assertEqual(project1,test,"failed to focus (using string) on project")

##        test=self.sMan.focusOnProject(project2)
##        self.assertEqual(self.sMan.currentProject().name,"newProject2","failed to focus (using object) on project")

        # Test for python package namespace change on focus.
   ##     self.sMan.setUp()
##        N=10
##        projects=[]
##        for x in range(N):
##            projects.append(self.sMan.newProject())

##        self.assert_(len(projects)==10,"Wrong number of projects created.")

##        for p in projects:
##            self.sMan.focusOnProject(p)
##            self.assert_(self.sMan.currentProject()==p,"Wrong current project.")
##            self.assert_(self.sMan.pythonPackage(), "No python package.")
##            self.assert_(self.sMan.pythonPackage().namespace==p,"Wrong namespace for the python package.")

    def testSaveProject(self):

        # test1
        self.sMan.setUp()
        project0 = self.sMan.newProject("newProject0")
        self.sMan.focusOnProject("newProject0")
        sname = self.sMan.saveProject()
        self.sMan.setUp()
        self.sMan.loadProject("newProject0.iml")
        self.assert_(self.sMan.currentProject().name == project0.name, "Failure in saveProject: the proper project was not loaded")
        self.assert_(sname == "newProject0", "Failure in saveProject: the proper filename was not returned.")

        # test2
        self.sMan.setUp()
        sname = self.sMan.saveProject()
        self.assert_(sname == None, "Failure in saveProject: None -value was not returned.")

        # Cleanup the files:
        try:
            os.remove("newProject0.iml")
        except:
            pass

    def testSaveProjectAs(self):

        # test1
        self.sMan.setUp()
        project2 = self.sMan.newProject("newProject2")
        self.sMan.focusOnProject("newProject2")
        sname = self.sMan.saveProjectAs("newProject2.iml")
        self.sMan.setUp()
        self.sMan.loadProject("newProject2.iml")
        self.assert_(self.sMan.currentProject().name == project2.name, "Failure in saveProjectAs: the proper project was not loaded back")
        self.assert_(sname == "newProject2", "Failure in saveProjectAs: the proper filename was not returned.")

        # test2
        self.sMan.setUp()
        sname = self.sMan.saveProjectAs("newProject3.iml")    
        self.assert_(sname == None, "Failure in saveProjectAs: None -value was not returned.")

        # Cleanup the files:
        try:
            os.remove("newProject2.iml")
        except:
            pass

    def testLoadProject(self):

        # Test with multiple files on disk (unnessary)
        self.sMan.setUp()
        projects=[]
        fnames=[]
        N=3
        for x in range(N):
            p=self.sMan.newProject()
            projects.append(p)
            fnames.append(p.name+".iml")
            self.assert_(p,"Project was not created.")
            rv=self.sMan.saveProject()
            self.assert_(rv==p.name,"Wrong returnvalue on save.")
            self.sMan.setUp()
            self.assert_(not self.sMan.currentProject(),"Current project should be none")

        #loading begins:
        for x in range(N):
            rv=self.sMan.loadProject(p.name+".iml")
            self.assert_(rv, "Wrong return value on load.")
            self.assert_(self.sMan.currentProject().name==projects[x].name, "Wrong project loaded back.")
            self.sMan.setUp()
            self.assert_(not self.sMan.currentProject(),"Current project should be none.")

        removeFiles(fnames) # cleanup

        # Testing with invalid parameters:
        self.sMan.setUp()
        ivalues=[None,mkUniqueStr(),metamodel.Model(),"invalid.name"]
        for iv in ivalues:
            rv=self.sMan.loadProject(iv)
            self.assert_(not rv, 'Wrong return value with parameter: %s' % iv) 
            self.assert_(not self.sMan.currentProject(), "Current project should be none.")

        # Trying to load project with an existing project with the same name. and also with a project
        # with different name
        self.sMan.setUp()
        name=mkUniqueStr()
        fnames=[name+".iml"]
        p=self.sMan.newProject(name)
        self.assert_(p,"Project was not created.")
        self.sMan.saveProject()
        self.assert_(self.sMan.currentProject()==p, "Current project is inocorrect.")
        # project with the same name:
#        self.sMan.setUp()
        lp=self.sMan.loadProject(p.name)
        self.assert_(not lp,"No project should be loaded.")
        self.assert_(self.sMan.currentProject()==p, "Current project is inocorrect.")
        # project with different name:
        self.sMan.setUp()
        p2=self.sMan.newProject()
        self.assert_(p2,'project was not created')
        lp=self.sMan.loadProject(p.name)
        self.assert_(not lp,"No project should be loaded.")
        self.assert_(self.sMan.currentProject()==p2, "Current project is inocorrect.")

        removeFiles(fnames)

##        # test1
##        self.sMan.setUp()
##        project4 = self.sMan.newProject("newProject4")
##        self.sMan.focusOnProject("newProject4")

##        self.sMan.saveProject()
##        self.sMan.setUp()
##        uModel=self.sMan.loadProject("newProject4")
##        self.assert_(uModel.name == project4.name, "Failure in loadProject: the proper project was not returned.")
##        self.assert_(self.sMan.currentProject().name == project4.name, "Failure in loadProject: the _currentProject variable was not properly set.")
##        self.assert_(self.sMan.projects().has_key("newProject4"), "Failure in loadProject: the project was not added to the projects() -dictionary.")

##        #test 3: tests that loading causes one class to be assigned to  current element.

##        self.sMan.setUp()
##        project5=self.sMan.newProject("newProject5")

##        self.sMan.saveProject()

##        self.sMan.setUp()
##        self.sMan.loadProject("newProject5")
##       # self.assertEqual(self.sMan.currentElement().name,project5.name,"The project should be the current element after load.")

###        self.sMan.newClass("class1")

##       # self.assertEqual(self.sMan.currentElement().name,"class1","The class should be current element before saving")

##        self.sMan.saveProject()

##        self.sMan.setUp()
##        self.sMan.loadProject("newProject5")
##       # self.assertEqual(self.sMan.currentElement().name,project5.name,"The project should be the current element after load.")

##                ####
##        a=[]
##        self.sMan.setUp()
##        for x in range(5):
##            self.sMan.newProject()
##            a.append(self.sMan.saveProject())

##        self.sMan.setUp()
##        for x in range(5):
##            sname=a.pop(0)
##            self.sMan.loadProject(sname)
##        for x in range(5):
##            self.sMan.newProject()

##        self.assert_(len(self.sMan.projects().keys())==10, "Failure in newProject: could not create new files")

        #THIS TEST WILL BE UPDATED
        # test that the python package is the same after loading
 ##       a=[]
##        self.sMan.setUp()
##        for x in range(5):
##            self.sMan.newProject()
##            a.append(self.sMan.saveProject())

##        self.sMan.setUp()
##        for x in range(5):
##            sname=a.pop(0)
##            p=self.sMan.loadProject(sname)
##            self.assert_(p,"Project was not loaded back.")
##            elements=self.sMan._layerManager.returnElements(p)
##            ppack=None
##            for e in elements:
##                if (e.oclIsKindOf(metamodel.Package) and e.name=="python2.2"):
##                    ppack=e
##            self.assert_(ppack, "Python package was not found.")
##            self.assert_(ppack==self.sMan.pythonPackage(),"Wrong python package instance.")
##            self.assert_(ppack.namespace, "No namespace for the ppackage.")

##            try:
##                os.remove(sname+".xml")
##            except:
##                pass

##        # Cleanup the files:
##        try:
##            os.remove("newProject4.xml")
##            os.remove("newProject5.xml")
##            os.remove("noname1.xml")
##            os.remove("noname2.xml")
##            os.remove("noname3.xml")
##            os.remove("noname4.xml")
##            os.remove("noname5.xml")

##        except:
##            pass

if __name__ == '__main__':

    obj2test = SfiManager()
    unittest.main()

[Pymerase-cvs-commit] smw/smw/scw/Project/unittests __init__.py,NONE,1.1 testSfiManager.py,NONE,1.1