[Pymerase-cvs-commit] smw/smw/scw/Correctness/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/Correctness/unittests
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/scw/Correctness/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__ = 'Correctness'

import unittest
from smw.metamodel import UML14 as metamodel
from smw.metamodel.UML14 import *
from smw.scw.Correctness.LayerManager import LayerManager
from smw.scw.Correctness.SfiManager import SfiManager
from smw.scw.Layer.unittests.testLayerManager import testLayerManager as LayerTestLayerManager


class testLayerManager(LayerTestLayerManager):

    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__ = 'Correctness'

import unittest
from smw.metamodel import UML14 as metamodel
from smw.metamodel.UML14 import *
#from LayerManager import LayerManager
from smw.scw.Correctness.SfiManager import SfiManager
from smw.scw.Layer.unittests.testSfiManager import testSfiManager as LayerTestSfiManager
from smw.scw.Project.unittests.testSfiManager import mkUniqueStr
from smw.io import *
import os
import os.path
import sys
from smw.scw.py2uml import *
import popen2

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

    def setUp(self):
        self.sMan = obj2test


    def testTaggingNewProjects(self):
        self.sMan.setUp()
        for x in range(1):
            proj=self.sMan.newProject()
            self.assert_(proj,'project was not created')
            tagNames=[]
            for x in proj.taggedValue:
                tagNames.append(x.name)
            self.assert_("correctness" in tagNames,"%s The correctness tag was not created" %x) 


    def testTaggingLayers(self):
        self.sMan.setUp()
        proj=self.sMan.newProject()
        for x in range(10):
            layer=self.sMan.newLayer()
            tagNames=[]
            for x in layer.taggedValue:
                tagNames.append(x.name)
            self.assert_("correctness" in tagNames,"%s The correctness tag was not created" %x)

        # Testing for tag value in 'inherited' class
        l1=self.sMan.newLayer([],[])
        self.assert_(l1,"Layer was not created.")
        self.sMan.focusOnElement(l1)
        c1=self.sMan.newClass()
        l2=self.sMan.newLayer([l1],[])
        classes=l2.ownedElement.select(lambda x: x.name==c1.name)
        self.assert_(len(classes)==1,"Class was no created to successor.")
        c=classes[0]
        tags=c.taggedValue.select(lambda x: x.name=="correctness")
        self.assert_(len(tags)==1,"Tag was not added to inherited class.")

    def testAttachingTags(self):
        elements=[]
        self.sMan.setUp()
        proj=self.sMan.newProject()
        class1=self.sMan.newClass()
        elements.append(class1)
        self.sMan.focusOnElement(proj)
        pack=self.sMan.newPackage()
        elements.append(pack)
        self.sMan.focusOnElement(proj)
        ##int=self.sMan.newInterface()
##        elements.append(int)
        
        for y in elements:
            tagNames=[]
            for x in y.taggedValue:
                tagNames.append(x.name)
            self.assert_("correctness" in tagNames, "%s The correctness tag was not created" %y) 

        # test that creating new elements affects recursively to previous levels
        self.sMan.setUp()
        proj=self.sMan.newProject()
        layer1=self.sMan.newLayer()
        self.sMan.focusOnElement(layer1)
        pack1=self.sMan.newPackage()

        for x in layer1.taggedValue:
            if x.name=="correctness":
                x.dataValue="all tests passed"
                
        for x in pack1.taggedValue:
            if x.name=="correctness":
                x.dataValue="all tests passed"

        self.sMan.focusOnElement(layer1)
        self.sMan.newClass()

        for x in layer1.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="undefined","Should update the layer tag to undefined")

        for x in pack1.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="all tests passed","shouldn't update the package tag")  
        
        self.sMan.focusOnElement(pack1)
        self.sMan.newClass()

        for x in pack1.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="undefined","should update the package tag")  
                

    def testLoadProject99(self):
        self.sMan.setUp()
        sname=mkUniqueStr()+'.iml'
        mname=mkUniqueStr()
        cname=mkUniqueStr()
        p1name=mkUniqueStr()
        p2name=mkUniqueStr()
        c1name=mkUniqueStr()
        
        m=metamodel.Model()
        m.name=mname
    
        p1=metamodel.Package()
        p1.name=p1name
        p1.namespace=m
        p2=metamodel.Package()
        p2.name=p2name
        p2.namespace=m
        c=metamodel.Class()
        c.name=cname
        c.namespace=p2
        c1=metamodel.Class()
        c1.name=c1name
        c1.namespace=m
        rv=saveModel(sname,m)
        self.assert_(rv,'saving was unsuccesful')
        self.sMan.setUp()
        p=self.sMan.loadProject(sname)
  
        self.assert_(isinstance(p,metamodel.Model),'loading was unsuccesful')
        self.assertEqual(p,self.sMan.currentProject(),'wrong current project')
    
        eles=self.sMan.layerManager().returnElements(p)
        ele=[]
        for e in eles:
            if e.oclIsKindOf(metamodel.Classifier) or e.oclIsKindOf(metamodel.Package):
                ele.append(e)
               
        for el in ele:
            inapp=None
            if not (el.oclIsKindOf(metamodel.Model)):
                ns=el.namespace
                while not ns==p:
                    if ns.name=='python2_2':
                        inapp=1
                        ns=p
                    else:
                        ns=ns.namespace
            onames=[]
                          
            for i in el.taggedValue:
                onames.append(i.name)
                if not self.sMan.layerManager().isTestClass(el) and not inapp and not el.name=="python2_2":
                    self.assert_("correctness" in onames, "The correctness-tag was not created")
                else:
                    self.assert_(not "correctness" in onames, "'correctness' tag should not be created into a testClass")
        popen2.popen2("rm "+sname)
                    
    def testCorrectnessNewLayer(self):
        self.sMan.setUp()
        self.sMan.newProject()
        l0=self.sMan.newLayer()
        self.sMan.focusOnElement(l0)
        self.sMan.newClass()
        self.sMan.focusOnElement(l0)
        #self.sMan.newInterface()
        self.sMan.focusOnElement(l0)
        l0p0=self.sMan.newPackage()
        self.sMan.focusOnElement(l0p0)
        self.sMan.newClass()
        self.sMan.focusOnElement(l0p0)
        #self.sMan.newInterface()
        self.sMan.focusOnElement(l0p0)
        self.sMan.newPackage()
        l1=self.sMan.newLayer(anc=l0)
        self.assert_(l1,'Layer was not created.')
        elements=[l1]
        while (elements):
            e=elements.pop()
            if (isinstance(e,Classifier) or isinstance(e,Package)) \
               and not self.sMan.layerManager().isTestClass(e):
                tg=e.taggedValue.select(lambda x: x.name=="correctness")
                self.assert_(len(tg)==1,'Wrong number of correctness tags for %s' %e)
                self.assert_(tg[0].dataValue=="undefined","wrong initial value on layer correctness tag")
            if isinstance(e,Package):
                for pe in e.ownedElement:
                    elements.append(pe)
        
    def testCorrectnessNewClass(self):
        self.sMan.setUp()
        self.sMan.newProject()
        l0=self.sMan.newLayer()
        l1=self.sMan.newLayer(anc=l0)
        self.sMan.focusOnElement(l0)
        self.sMan.newClass()
        self.sMan.focusOnElement(l0)
        l0p0=self.sMan.newPackage()
        self.sMan.focusOnElement(l0p0)
        self.sMan.newClass()
        elements=[l1]
        while (elements):
            e=elements.pop()
            if (isinstance(e,Classifier) or isinstance(e,Package)) \
               and not self.sMan.layerManager().isTestClass(e):
                tg=e.taggedValue.select(lambda x: x.name=="correctness")
                self.assert_(len(tg)==1,'Wrong number of correctness tags for %s' %e)
                self.assert_(tg[0].dataValue=="undefined","wrong initial value on Class correctness tag")

            if isinstance(e,Package):
                for pe in e.ownedElement:
                    elements.append(pe)

    ##def testCorrectnessNewInterface(self):
##        self.sMan.setUp()
##        self.sMan.newProject()
##        l0=self.sMan.newLayer()
##        l1=self.sMan.newLayer(anc=l0)
##        self.sMan.focusOnElement(l0)
##        self.sMan.newInterface()
##        self.sMan.focusOnElement(l0)
##        l0p0=self.sMan.newPackage()
##        self.sMan.focusOnElement(l0p0)
##        self.sMan.newInterface()
##        elements=[l1]
##        while (elements):
##            e=elements.pop()
##            if (isinstance(e,Classifier) or isinstance(e,Package)) \
##               and not self.sMan.layerManager().isTestClass(e):
##                tg=e.taggedValue.select(lambda x: x.name=="correctness")
##                self.assert_(len(tg)==1,'Wrong number of correctness tags for %s' %e)
##            if isinstance(e,Package):
##                for pe in e.ownedElement:
##                    elements.append(pe)


    def testCorrectnessNewPackage(self):
        self.sMan.setUp()
        self.sMan.newProject()
        l0=self.sMan.newLayer()
        l1=self.sMan.newLayer(anc=l0)
        self.sMan.focusOnElement(l0)
        self.sMan.newPackage()
        self.sMan.focusOnElement(l0)
        l0p0=self.sMan.newPackage()
        self.sMan.focusOnElement(l0p0)
        self.sMan.newPackage()
        elements=[l1]
        while (elements):
            e=elements.pop()
            if (isinstance(e,Classifier) or isinstance(e,Package)) \
               and not self.sMan.layerManager().isTestClass(e):
                tg=e.taggedValue.select(lambda x: x.name=="correctness")
                self.assert_(len(tg)==1,'Wrong number of correctness tags for %s' %e)
                self.assert_(tg[0].dataValue=="undefined","wrong initial value on Package correctness tag")

            if isinstance(e,Package):
                for pe in e.ownedElement:
                    elements.append(pe)

    def testAttachSuccessorTags(self):
        self.sMan.setUp()
        self.sMan.newProject()
        # Direct testing not possible... useless test
        D=2 # depth (packages)
        N=5 # lenght of chain
        B=2 # nro of branches
        l0=self.sMan.newLayer()
        a=l0
        for x in range(B):
            ln=self.sMan.newLayer(anc=a)
            a2=ln
            for y in range(N):
                ln2=self.sMan.newLayer(anc=a2)
                a2=ln2
        ns=l0
        for x in range(D):
            self.sMan.focusOnElement(ns)
            pd=self.sMan.newPackage()
            self.sMan.focusOnElement(ns)
            cd=self.sMan.newClass()
            self.sMan.focusOnElement(ns)
            #id=self.sMan.newInterface()
            ns=pd

        layers=[l0]
        while (layers):
            #for x in range(D):
            e=layers.pop()
            layers.extend(self.sMan.layerManager().successors(e))
            for x in range(D):
                for oe in e.ownedElement:
                    if (isinstance(oe,Classifier) or isinstance(oe,Package)) \
                       and not self.sMan.layerManager().isTestClass(oe):
                        tg=oe.taggedValue.select(lambda x: x.name=="correctness")
                        self.assert_(len(tg)==1,'Wrong number of correctness tags for %s' %oe)
                e=e.ownedElement.select(lambda x: isinstance(x,Package))[0]
   

if __name__ == '__main__':
    obj2test = SfiManager()
    suite=unittest.TestLoader().loadTestsFromTestCase(testSfiManager)
    unittest.TextTestRunner().run(suite)