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

[<de...@us...>]

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

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

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

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

__layer__ = 'UndoRedo'

import unittest
from smw.metamodel import UML14 as metamodel
from smw.metamodel.UML14 import *
from smw.scw.UndoRedo.LayerManager import LayerManager
from smw.scw.UndoRedo.SfiManager import SfiManager
from smw.scw.Correctness.unittests.testLayerManager import testLayerManager as CorrectnessTestLayerManager



class testLayerManager(CorrectnessTestLayerManager):

    def setUp(self):
        self.lMan = LayerManager()
	self.model = Model()
  
if __name__ == '__main__':

    # obj2test = SfiManager()
    # suite = unittest.TestLoader().loadTestsFromTestCase(testLayerManager)
    # unittest.TextTestRunner().run(suite)
    unittest.main()
    

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

__layer__ = 'UndoRedo'

import unittest
from smw.metamodel import UML14 as metamodel
#from LayerManager import LayerManager
from smw.scw.UndoRedo.SfiManager import SfiManager
from smw.scw.Correctness.unittests.testSfiManager import testSfiManager as CorrectnessTestSfiManager

class testSfiManager(CorrectnessTestSfiManager):
# class testSfiManager(unittest.TestCase):

    def setUp(self):
        self.sMan=obj2test
       
     
    #Testing undo and redo functions, separate test for each undoable/redoable method
    
    def testUndoRedoNewClass(self):
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project=self.sMan.newProject()
        self.assert_(project,"project was not created")

        class1=self.sMan.newClass()
        self.assert_(class1,"class1 was not created")
        dep=self.sMan.layerManager().getTestDependency(class1)
        self.assert_(dep,"test dependency was not found")
        #dep=class1.supplierDependency[0]
        #testClass1=dep.client[0]
        testClass1=self.sMan.layerManager().getTestClient(class1)
        self.assert_(testClass1,"test class was not found")

        self.sMan.undo()#should undo newClass()

        self.assert_(self.sMan.layerManager().returnElements(project).count(class1)==0,"The class should not be in the project")
        self.assert_(self.sMan.layerManager().returnElements(project).count(dep)==0,"The dependency should not be in the project")
        self.assert_(self.sMan.layerManager().returnElements(project).count(testClass1)==0,"The dependency should not be in the project")
        self.assertEqual(self.sMan.currentElement(),project, "wrong currentElement after undo ")

        self.sMan.redo()

        self.assert_(self.sMan.layerManager().returnElements(project).count(class1)==1,"The class should not be in the project")
        self.assert_(self.sMan.layerManager().returnElements(project).count(dep)==1,"The dependency should not be in the project")
        self.assert_(self.sMan.layerManager().returnElements(project).count(testClass1)==1,"The dependency should not be in the project")
        self.assertEqual(self.sMan.currentElement(),project, "wrong currentElement after undo ")
        self.sMan.focusOnElement(project)

        countBefore=len(self.sMan.layerManager().returnElements(project))
        for x in range(10):
            self.sMan.newClass()
            self.sMan.focusOnElement(project)

        countAfter=len(self.sMan.layerManager().returnElements(project))

        for x in range(10):
            self.sMan.undo()

        self.assertEqual(len(self.sMan.layerManager().returnElements(project)),countBefore, "failed to undo creating new classes")

        for x in range(10):
            self.sMan.redo()

        self.assertEqual(len(self.sMan.layerManager().returnElements(project)),countAfter, "failed to undo creating new classes")



    def testUndoRedoNewInterface(self):

        self.sMan.setUp()
        self.sMan.project().history.clear()

        project=self.sMan.newProject()

        interface1=self.sMan.newInterface()
   
        self.sMan.undo()

        self.assert_(self.sMan.layerManager().returnElements(project).count(interface1)==0,"The interface should not be in the project")
        self.assertEqual(self.sMan.currentElement(),project, "wrong currentElement after undo ")

        self.sMan.redo()

        self.assert_(self.sMan.layerManager().returnElements(project).count(interface1)==1,"The interface should not be in the project")
        self.assertEqual(self.sMan.currentElement(),project, "wrong currentElement after undo ")

        countBefore=len(self.sMan.layerManager().returnElements(project))
        for x in range(10):
            self.sMan.newInterface()
            self.sMan.focusOnElement(project)

        countAfter=len(self.sMan.layerManager().returnElements(project))

        for x in range(10):
            self.sMan.undo()

        self.assertEqual(len(self.sMan.layerManager().returnElements(project)),countBefore, "failed to undo creating new interfaces")

        for x in range(10):
            self.sMan.redo()

        self.assertEqual(len(self.sMan.layerManager().returnElements(project)),countAfter, "failed to undo creating new interfaces")

        
    def testUndoRedoNewGeneralization(self):
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project = self.sMan.newProject()

        class1 = self.sMan.newClass()
        self.sMan.focusOnElement(project)
        interface1 = self.sMan.newInterface()

        gen1=self.sMan.newGeneralization(class1, interface1, "gen1")
        self.sMan.undo()
        self.assert_(self.sMan.layerManager().returnElements(project).count(gen1) == 0, " Failed to undo creating generalization.")
        self.assert_(self.sMan.currentElement() == project, " Failed: wrong currentElement.")
        self.sMan.redo()
        self.assert_(self.sMan.layerManager().returnElements(project).count(gen1) == 1, " Failed to redo creating generalization..")
        self.assert_(self.sMan.currentElement() == project, " Failed: wrong currentElement.(2)")
        
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project = self.sMan.newProject()


        interfaces = []
        classes = []
        for x in range(10):
            interfaces.append(self.sMan.newInterface())
            self.sMan.focusOnElement(project)
            classes.append(self.sMan.newClass())
            self.sMan.focusOnElement(project)

        startingCount = len(self.sMan.layerManager().returnElements(project))
                

        for x in range(10):
            self.sMan.newGeneralization(interfaces[x], classes[x])

        afterCount =len(self.sMan.layerManager().returnElements(project))

        for x in range(10):
            self.sMan.undo()

        self.assert_(startingCount == len(self.sMan.layerManager().returnElements(project)), "Failed in undoiing multiple generalization instances.")

        for x in range(10):
            self.sMan.redo()

        self.assert_(afterCount == len(self.sMan.layerManager().returnElements(project)), "Failed in redoiing multiple generalization instances.")


    def testUndoRedoNewAssociation(self):
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project = self.sMan.newProject()

        class1 = self.sMan.newClass()
        self.sMan.focusOnElement(project)
        interface1 = self.sMan.newInterface()

        ass1=self.sMan.newAssociation(class1, interface1, "ass1")
        self.sMan.undo()
        self.assert_(self.sMan.layerManager().returnElements(project).count(ass1) == 0, " Failed to undo creating association.")
        self.assert_(self.sMan.currentElement() == project, " Failed: wrong currentElement.")
        self.sMan.redo()
        self.assert_(self.sMan.layerManager().returnElements(project).count(ass1) == 1, " Failed to redo creating association.")
        self.assert_(self.sMan.currentElement() == project, " Failed: wrong currentElement.(2)")
        
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project = self.sMan.newProject()


        interfaces = []
        classes = []
        for x in range(10):
            interfaces.append(self.sMan.newInterface())
            self.sMan.focusOnElement(project)
            classes.append(self.sMan.newClass())
            self.sMan.focusOnElement(project)

        startingCount = len(self.sMan.layerManager().returnElements(project))

        for x in range(10):
            self.sMan.newAssociation(interfaces[x], classes[x])

        afterCount =len(self.sMan.layerManager().returnElements(project))

        for x in range(10):
            self.sMan.undo()

        self.assert_(startingCount == len(self.sMan.layerManager().returnElements(project)), "Failed in undoiing multiple association instances.")

        for x in range(10):
            self.sMan.redo()

        self.assert_(afterCount == len(self.sMan.layerManager().returnElements(project)), "Failed in redoiing multiple association instances.")


    def testUndoRedoNewDependency(self):
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project = self.sMan.newProject()

        pack1 = self.sMan.newPackage()

        attr1 = self.sMan.newOperation()
        self.sMan.focusOnElement(project)
        interface1 = self.sMan.newInterface()

        dep1=self.sMan.newDependency(attr1, interface1, "dep1")
        self.sMan.undo()
        self.assert_(self.sMan.layerManager().returnElements(project).count(dep1) == 0, " Failed to undo creating dependency.")
        self.assert_(self.sMan.currentElement() == project, " Failed: wrong currentElement.")
        self.sMan.redo()
        self.assert_(self.sMan.layerManager().returnElements(project).count(dep1) == 1, " Failed to redo creating dependency.")
        self.assert_(self.sMan.currentElement() == project, " Failed: wrong currentElement.(2)")
    
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project = self.sMan.newProject()


        interfaces = []
        classes = []
        for x in range(10):
            interfaces.append(self.sMan.newInterface())
            self.sMan.focusOnElement(project)
            classes.append(self.sMan.newClass())
            self.sMan.focusOnElement(project)

        startingCount = len(self.sMan.layerManager().returnElements(project))
                
        for x in range(10):
            self.sMan.newDependency(interfaces[x], classes[x])

        afterCount =len(self.sMan.layerManager().returnElements(project))

        for x in range(10):
            self.sMan.undo()

        self.assert_(startingCount == len(self.sMan.layerManager().returnElements(project)), "Failed in undoing multiple dependencies")

        for x in range(10):
            self.sMan.redo()

        self.assert_(afterCount == len(self.sMan.layerManager().returnElements(project)), "Failed in redoing multiple dependencies.")


    def testUndoRedoNewPackage(self):
        self.sMan.setUp()
        project1=self.sMan.newProject("myproject")
        pack1=self.sMan.newPackage("pack1")
        self.assert_(self.sMan.layerManager().returnElements(project1).count(pack1)==1, "Package should be added to  the project")

        self.sMan.undo()
 
        self.assert_(self.sMan.currentElement()==project1, "Current element should be the myproject after undo.")
        self.assert_(self.sMan.layerManager().returnElements(project1).count(pack1)==0, "Package should not be in the project")

        self.sMan.redo()

      #  self.assert_(self.sMan.currentElement==pack1, "Current element should be package after redo")
        self.assert_(self.sMan.layerManager().returnElements(project1).count(pack1)==1,"Package should be in project after redo")
        # testing with multiple packet instances.
      
        self.sMan.setUp()
        project1=self.sMan.newProject("myproject")

        packages = []
        for x in range (10):
            packages.append(self.sMan.newPackage())

        packages.reverse()
            
        for x in packages:
           # self.assertEqual(x,self.sMan.currentElement(),"Wrong currentElement in the project")
            self.assert_(self.sMan.layerManager().returnElements(project1).count(x)==1,"The project1 was not on the list.")
            self.sMan.undo()
            self.assert_(self.sMan.layerManager().returnElements(project1).count(x)==0,"The package was not deleted.")

        self.assertEqual(project1,self.sMan.currentElement(),"CurrentElement should be the project1")


        # testing creating new packages inside each other
        elementsBefore=self.sMan.layerManager().returnElements(project1)

        for x in range(10):
            self.sMan.newPackage()
            
        elementsAfter=self.sMan.layerManager().returnElements(project1)

        for x in range(10):
            self.sMan.undo()
            self.assertEqual(self.sMan.currentElement(),project1,\
                             "the current element should be  project1 after undo")
        elementsAfterUndo=self.sMan.layerManager().returnElements(project1)
            
        self.assertEqual(len(elementsAfter)-20,len(elementsBefore), "Count does not match") #-10
        self.assertEqual(len(elementsBefore),len(elementsAfterUndo),"count does not match")

        #little test for redo
    
        elementsBefore=self.sMan.layerManager().returnElements(project1)

        for x in range(10):
            self.sMan.redo()

        self.assertEqual(len(self.sMan.layerManager().returnElements(project1)),len(elementsAfter),\
                         "redo does not work")
       
        
        # testing creating new packages directly to the project
        elementsBefore=self.sMan.layerManager().returnElements(project1)
        for x in range(10):
            self.sMan.newPackage()
            self.sMan.focusOnElement(project1)

        elementsAfter=self.sMan.layerManager().returnElements(project1)

        for x in range(10):
            self.sMan.undo()

        elementsAfterUndo=self.sMan.layerManager().returnElements(project1)
        self.assertEqual(len(elementsAfter)-20,len(elementsBefore), "Count does not match")
        self.assertEqual(len(elementsBefore),len(elementsAfterUndo),"count does not match")

        # testing with one package and one failure
        self.sMan.setUp()
        project1=self.sMan.newProject("myproject")
        pack1 = self.sMan.newPackage("Packet")
        self.sMan.focusOnElement(project1)
        pack2 = self.sMan.newPackage("Packet") # should return None
        self.sMan.undo()#should undo creating pack1
        self.assert_(self.sMan.layerManager().returnElements(project1).count(pack1) == 0,\
                     "pack1 should not be in the project after undo.")
        
    def testUndoRedoNewMethod(self):
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project=self.sMan.newProject()

        class1=self.sMan.newClass()
        self.assert_(class1,"class was not created")
        testClass1=self.sMan.layerManager().getTestClient(class1)
        self.assert_(testClass1,"test class was not found")
        #testclass1=class1.supplierDependency[0].client[0]
        method1=self.sMan.newMethod()
        self.assert_(method1,"method was not created")

        testMethod1=None
        for x in testClass1.feature:
            if isinstance(x,metamodel.Method):
                testMethod1=x


        self.sMan.undo()

        self.assert_(self.sMan.layerManager().returnElements(project).count(method1)==0,"The method1 should not be in the project")
        self.assert_(self.sMan.layerManager().returnElements(project).count(testMethod1)==0,"The test method should not be in the project")
        self.assertEqual(self.sMan.currentElement(),project, "wrong currentElement after undo ")

        self.sMan.redo()

        self.assert_(self.sMan.layerManager().returnElements(project).count(method1)==1,"The method1 should be in the project")
        self.assert_(self.sMan.layerManager().returnElements(project).count(testMethod1)==1,"The testmethod1 should be in the project")
        self.assertEqual(self.sMan.currentElement(),project, "wrong currentElement after undo ")
        self.sMan.focusOnElement(project)

        class1=self.sMan.newClass()
        countBefore=len(self.sMan.layerManager().returnElements(project))
        for x in range(10):
            self.sMan.newMethod()
            self.sMan.focusOnElement(class1)

        countAfter=len(self.sMan.layerManager().returnElements(project))

        for x in range(10):
            self.sMan.undo()

        #print countAfter
  
        self.assertEqual(len(self.sMan.layerManager().returnElements(project)),countBefore, "failed to undo creating new methods")

        for x in range(10):
            self.sMan.redo()
    
        self.assertEqual(len(self.sMan.layerManager().returnElements(project)),countAfter, "failed to undo creating new methods")



    def testUndoRedoNewAttribute(self):

        self.sMan.setUp()
        self.sMan.project().history.clear()
        project=self.sMan.newProject()

        class1=self.sMan.newClass()
    
        oper1=self.sMan.newOperation()
       
        self.sMan.undo()

        self.assert_(self.sMan.layerManager().returnElements(project).count(oper1)==0,"The attribute should not be in the project")
        self.assertEqual(self.sMan.currentElement(),project, "wrong currentElement after undo ")

        self.sMan.redo()

        self.assert_(self.sMan.layerManager().returnElements(project).count(oper1)==1,"The attribute should not be in the project")
        self.assertEqual(self.sMan.currentElement(),project, "wrong currentElement after undo ")
        self.sMan.focusOnElement(project)

        interface1=self.sMan.newInterface()
        countBefore=len(self.sMan.layerManager().returnElements(project))
        for x in range(10):
            self.sMan.newAttribute()
            self.sMan.focusOnElement(interface1)

        countAfter=len(self.sMan.layerManager().returnElements(project))

        for x in range(10):
            self.sMan.undo()

        self.assertEqual(len(self.sMan.layerManager().returnElements(project)),countBefore, "failed to undo creating new attributes")

        for x in range(10):
            self.sMan.redo()

        self.assertEqual(len(self.sMan.layerManager().returnElements(project)),countAfter, "failed to undo creating new attributes")

##    def testUndoRedoDeleteElement1(self):
##        self.sMan.setUp()
##        self.sMan.project().history.clear()
##        project=self.sMan.newProject()

    
##        class1 = self.sMan.newClass()
##        self.sMan.deleteElement1(class1)
    
##        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 0, "Delete Element did not work.")
##        self.sMan.undo()
##        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 1, "Undoing delete did not work.")
##        self.sMan.redo()
##        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 0, "redoing Delete Element did not work.")

        
##        pack1 = self.sMan.newPackage()
##        class1 = self.sMan.newClass()
##        dep1 = class1.supplierDependency[0]
##        testclass1 = dep1.client[0]
                
##        self.sMan.deleteElement1(pack1)
    
##        self.assert_(self.sMan.layerManager().returnElements(project).count(pack1) == 0, "Delete Element did not work(1).")
##        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 0, "Delete Element did not work)(2).")
##        self.assert_(self.sMan.layerManager().returnElements(project).count(dep1) == 0, "Delete Element did not work.(3)")
##        self.assert_(self.sMan.layerManager().returnElements(project).count(testclass1) == 0, "Delete Element did not work.(4)")

##        self.sMan.undo()
        
##        self.assert_(self.sMan.layerManager().returnElements(project).count(pack1) == 1, "Undoing delete did not work.(1)")
##        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 1, "Undoing delete did not work.(2)")
##        self.assert_(self.sMan.layerManager().returnElements(project).count(dep1) == 1, "Undoing delete did not work.(3)")
##        self.assert_(self.sMan.layerManager().returnElements(project).count(testclass1) == 1, "Undoing delete did not work.(4)")
        
##        self.sMan.redo()
        
##        self.assert_(self.sMan.layerManager().returnElements(project).count(pack1) == 0, "redo Delete Element did not work(1).")
##        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 0, "redo Delete Element did not work)(2).")
##        self.assert_(self.sMan.layerManager().returnElements(project).count(dep1) == 0, "redo Delete Element did not work.(3)")
##        self.assert_(self.sMan.layerManager().returnElements(project).count(testclass1) == 0, "redo Delete Element did not work.(4)")

##        count1 = len(self.sMan.layerManager().returnElements(project))

##        interfaces = []
##        for x in range(10):
##            interfaces.append(self.sMan.newInterface())
##            self.sMan.focusOnElement(project)

##        count2 = len(self.sMan.layerManager().returnElements(project))

##        for x in range(10):
##            self.sMan.deleteElement1(interfaces[x])
            
##        count3 = len(self.sMan.layerManager().returnElements(project))
##        self.assert_(count3 == count1, "Counts do not match")

##        for x in range(10):
##            self.sMan.undo()
    
##        self.assert_(len(self.sMan.layerManager().returnElements(project)) == count2, "Undoing delete did not work.(1)")

##        for x in range(10):
##            self.sMan.redo()

##        self.assert_(len(self.sMan.layerManager().returnElements(project)) == count3, "redoing  delete did not work.(1)")



    def testUndoRedoDeleteElement2(self):
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project=self.sMan.newProject()

        class1 = self.sMan.newClass()

        testClass=self.sMan.layerManager().getTestClient(class1)

        self.sMan.deleteElement2(class1)
    
        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 0, "Delete Element did not work.")
        self.sMan.undo()
        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 1, "Undoing delete did not work.")
        self.sMan.redo()
        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 0, "redoing Delete Element did not work.")

        
        pack1 = self.sMan.newPackage()
        class1 = self.sMan.newClass()
        dep1 = class1.supplierDependency[0]
        testclass1 = dep1.client[0]
                
        self.sMan.deleteElement2(pack1)
    
        self.assert_(self.sMan.layerManager().returnElements(project).count(pack1) == 0, "Delete Element did not work(1).")
        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 0, "Delete Element did not work)(2).")
        self.assert_(self.sMan.layerManager().returnElements(project).count(dep1) == 0, "Delete Element did not work.(3)")
        self.assert_(self.sMan.layerManager().returnElements(project).count(testclass1) == 0, "Delete Element did not work.(4)")

        self.sMan.undo()
        
        self.assert_(self.sMan.layerManager().returnElements(project).count(pack1) == 1, "Undoing delete did not work.(1)")
        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 1, "Undoing delete did not work.(2)")
        self.assert_(self.sMan.layerManager().returnElements(project).count(dep1) == 1, "Undoing delete did not work.(3)")
        self.assert_(self.sMan.layerManager().returnElements(project).count(testclass1) == 1, "Undoing delete did not work.(4)")
        
        self.sMan.redo()
        
        self.assert_(self.sMan.layerManager().returnElements(project).count(pack1) == 0, "redo Delete Element did not work(1).")
        self.assert_(self.sMan.layerManager().returnElements(project).count(class1) == 0, "redo Delete Element did not work)(2).")
        self.assert_(self.sMan.layerManager().returnElements(project).count(dep1) == 0, "redo Delete Element did not work.(3)")
        self.assert_(self.sMan.layerManager().returnElements(project).count(testclass1) == 0, "redo Delete Element did not work.(4)")

        count1 = len(self.sMan.layerManager().returnElements(project))

        interfaces = []
        for x in range(10):
            interfaces.append(self.sMan.newInterface())
            self.sMan.focusOnElement(project)

        count2 = len(self.sMan.layerManager().returnElements(project))

        for x in range(10):
            self.sMan.deleteElement2(interfaces[x])
            
        count3 = len(self.sMan.layerManager().returnElements(project))
        self.assert_(count3 == count1, "Counts do not match")

        for x in range(10):
            self.sMan.undo()
    
        self.assert_(len(self.sMan.layerManager().returnElements(project)) == count2, "Undoing delete did not work.(1)")

        for x in range(10):
            self.sMan.redo()

        self.assert_(len(self.sMan.layerManager().returnElements(project)) == count3, "redoing  delete did not work.(1)")

        # generalization test
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project=self.sMan.newProject()

        class1 = self.sMan.newClass()
        self.sMan.focusOnElement(project)
        interface1 = self.sMan.newInterface()
        gen1 = self.sMan.newGeneralization(interface1, class1)
        count1 = len(self.sMan.layerManager().returnElements(project))
        self.sMan.deleteElement2(interface1)
        
        self.assert_(self.sMan.layerManager().returnElements(project).count(interface1) == 0, "Delete interface did not work(1).")
        self.assert_(self.sMan.layerManager().returnElements(project).count(gen1) == 0, "Delete2 did not work)(2).")

        self.sMan.undo()

        
        self.assert_(self.sMan.layerManager().returnElements(project).count(interface1) == 1, "Undoing delete2 did not work.(1)")
        self.assert_(self.sMan.layerManager().returnElements(project).count(gen1) == 1, "Undoing delete2 did not work.(2)")

        self.sMan.redo()
                
        self.assert_(self.sMan.layerManager().returnElements(project).count(interface1) == 0, "redoing Delete interface did not work(1).")
        self.assert_(self.sMan.layerManager().returnElements(project).count(gen1) == 0, "redoing Delete2 did not work)(2).")


    def testUndoRedoRenameElement(self):
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project=self.sMan.newProject()

        interface1 = self.sMan.newInterface("intface")
        t=self.sMan.renameElement(interface1, "newnameintface")
        self.sMan.undo()
        self.assert_(interface1.name == "intface", "Undoing rename element was not succesfull.")
        self.sMan.redo()
        self.assert_(interface1.name == "newnameintface", "redoing rename element was not succesfull.")


        # testing renaming with class and method
        self.sMan.setUp()
        self.sMan.project().history.clear()
        project=self.sMan.newProject()
        class1=self.sMan.newClass("oldclass")
        testClass1=self.sMan.layerManager().getTestClient(class1)
        method1=self.sMan.newMethod("oldmethod")
        for x in testClass1.feature:
            if x.oclIsKindOf(metamodel.Method):
                testMethod1=x
        
        self.assert_(testClass1.name=="testOldclass","testclass has wrong name")
        self.assert_(testMethod1.name=="testOldmethod","testmethod has wrong name")

        self.sMan.renameElement(class1,"newclass")
        self.sMan.renameElement(method1,"newmethod")
        
        self.assert_(testClass1.name=="testNewclass","testclass has wrong name")
        self.assert_(testMethod1.name=="testNewmethod","testmethod has wrong name")

        self.sMan.undo()
        self.sMan.undo()

        self.assert_(testClass1.name=="testOldclass","failed to undo renaming testclass")
        self.assert_(testMethod1.name=="testOldmethod","failed to undo renaming testmethod")

        self.sMan.redo()
        self.sMan.redo()

        self.assert_(testClass1.name=="testNewclass","failed to redo renaming testclass")
        self.assert_(testMethod1.name=="testNewmethod","failed to redo renaming testclass")
        
        self.sMan.project().history.clear()

    def testUndo(self):

        #testing calling undo without anything to undo

        self.sMan.setUp()
        self.sMan.project().history.clear()
        
        history=self.sMan.project().history

        self.sMan.undo()

        self.assertEqual(history,self.sMan.project().history, "there shouldn't have been anything to undo")
        

    def testRedo(self):
        #testing calling redo without anything to redo
        self.sMan.setUp()
        self.sMan.project().history.clear()
        
        history=self.sMan.project().history
        
        self.sMan.redo()
        
        self.assertEqual(history,self.sMan.project().history,"there shouldn't have been anything to redo.")
        
    
    
 
if __name__ == '__main__':
    #unittest.main()
    obj2test = SfiManager()
    suite=unittest.TestLoader().loadTestsFromTestCase(testSfiManager)
    unittest.TextTestRunner().run(suite)