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

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

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

Added Files:
	__init__.py testLayerManager.py testSfiManager.py 
	umlcoresupport.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__ = 'Layer'

import unittest
from smw.metamodel import UML14 as metamodel
from smw.metamodel.UML14 import *
from smw.scw.Layer.LayerManager import *
from smw.scw.Layer.SfiManager import SfiManager
from smw.scw.Element.unittests import testLayerManager as ElementTestLayerManager
from smw.scw.Project.unittests.testSfiManager import mkUniqueStr
from smw.scw.Element.LayerManager import mkTestCaseName


# todo:
# moving package out from layer --> layerpackagedependency? renaming it?
# fix ancestor tests fully.
# package unittestdependency rename to Element layer.
# rename layer package depdency, layer generalization when renaming class/interface or layer underneat
[...2864 lines suppressed...]
        fitem=[None,mkUniqueStr(),self.model,Package(),titem[0],titem[1],titem[2],titem[3]]
        # we are all set to test:
        for f in fitem:
            if fitem.index(f)!=0:
                self.assert_(f,'Item was not created properly.')
            for t in titem:
                g=self.lMan.addLayerGeneralization(f,t)
                self.assert_(not g,'Generalization was incorrectly created.')

 ##   def testUpdateLayerPackageDependencies(self):
##        pass

##    def testUpdateLayerGeneralizations(self):
        

        
if __name__ == '__main__':

    unittest.main()


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

__layer__ = 'Layer'

import unittest,os,os.path,sys
from smw.metamodel import UML14 as metamodel
from smw.metamodel.UML14 import *

from smw.scw.Project.unittests.testSfiManager import mkUniqueStr
from smw.scw.Element.unittests.testSfiManager import testSfiManager as ElementTestSfiManager
from smw.scw.Element.LayerManager import mkTestCaseName
from smw.scw.Layer.SfiManager import SfiManager
from smw.scw.Layer.LayerManager import mkLayerDependencyName

# todo:
# problem with existing name in successor layers
# change owner/namespace needs some work.

class testSfiManager(ElementTestSfiManager):
[...2821 lines suppressed...]
        self.assert_(c1,"failed to create a class.")
        c2=l2.ownedElement.select(lambda l:l.name==c1.name)[0]

        res=self.sMan.connectClasses(c1,c2)
        self.assert_(res,"Failed to connect classes.")
        classes=l1.ownedElement.select(lambda l: isinstance(l,metamodel.Class))
        self.assert_(len(classes)==0,"Failed to clean the highest layer.")
        classes=l2.ownedElement.select(lambda l: isinstance(l,metamodel.Class))
        self.assert_(len(classes)==2,"Didn't find the class and testclass in layer.")
        self.assert_(c1.namespace==None,"Failed to detach the class 1.")
        testClass=self.sMan.layerManager().getTestClient(c2)
        self.assert_(testClass,"test class not found.")
        utDep=testClass.generalization.select(lambda l:l.parent.name=="TestCase")
        self.assert_(len(utDep)==1,"Failed to move the inheritance of testcase to ancestor test class.")
        
if __name__ == '__main__':
    obj2test = SfiManager()
    suite=unittest.TestLoader().loadTestsFromTestCase(testSfiManager)
    unittest.TextTestRunner().run(suite)
 

--- NEW FILE: umlcoresupport.py ---

#Copyright 2001,2002 by Ivan Porres ip...@ab...
#
import copy
import inspect
import types
import string

   
class UMLClass:
    def __init__(self,**args):
        self.__initattrs__(**args)
        
    def __initattrs__(self,**args):
        for name in self.__mm__.keys():
            if not self.__dict__.has_key(name):
                (mmtype,multiplicity,otherRole,otherMultiplicity,qualifier,frozen)=self.__mm__[name]
                if qualifier:
                    self.__dict__[name]=UMLQAssociationEnd({},self,name,self.__mm__[name])
                else:
                    self.__dict__[name]=UMLAssociationEnd([],self,name,self.__mm__[name])

        for k in args.keys():
            self.__setattr__(k,args[k])


    def __resetattrs__(self):
        """sets the associations of a UMLCLass to default values. This method is usefull to unlik an object."""
        
        for name in self.__mm__.keys():
            (mmtype,multiplicity,otherRole,otherMultiplicity,qualifier, frozen)=self.__mm__[name]
            self.__setattr__(name,UMLAssociationEnd([],self,name,self.__mm__[name]))

    def __whereIsAttrDefined__(self,a,candidate=None):
        if not candidate:
            candidate=self.__class__
        for b in candidate.__bases__:
            if b.__mm__.has_key(a):
                candidate=b.__whereIsAttrDefined__(self,a,b)
        return candidate
    
    def __getstate__(self):
        # returns a dictionary with the state of the object
        # the dictionary does not contain empty attributes or association ends
        # since they are created by init
        dict=copy.copy(self.__dict__)
        for name in self.__mm__.keys():
            (mmtype,multiplicity,otherRole,otherMultiplicity,qualifier, frozen)=self.__mm__[name]
            if getattr(self,name).size()==0:
               del dict[name]
            else:
                if getattr(self,name)==None:
                    del dict[name]
        return dict
                
    def __setstate__(self,newstate):
        self.__initattrs__()
        for k in newstate.keys():
            self.__dict__[k]=newstate[k]
            
    def __setclass__(self,newclass):
        self.__class__=newclass
        self.__mm___=newclass.__mm__
        self.__initattrs__()
        
    def __setattr__(self,name,val):
        if self.__mm__.has_key(name):
            (mmtype,multiplicity,otherRole,otherMultiplicity,qualifier, frozen)=self.__mm__[name]

            if self.__dict__[name].__frozen__:
                raise "Updating a frozen association end"
            
            if self.__dict__[name] and otherRole:
                for x in  self.__dict__[name]:
                    x.__dict__[otherRole].remove(self)

            if type(val)!=types.ListType and not (
                type(val)==types.InstanceType and isinstance(
                val,UMLAssociationEnd)):
                     val=[val]
                     
            if type(val)==types.ListType:
                self.__dict__[name]=UMLAssociationEnd(val,self,name,self.__mm__[name])
            elif  type(val)==types.InstanceType and isinstance(val,UMLAssociationEnd):
                if val.__mm__[1]!=mmtype:
                    raise WFRException("TypeError: AssociationEnd has different mmtype")
                else:
                    # should it be a copy?
                    self.__dict__[name]=val

            else:
                raise WFRException("TypeError: it should be list or UMLAssociationEnd")
                                                                                            
        else:
            # attribute or association not found
            #raise "TypeError: Attribute or association not found"
            self.__dict__[name]=val

    def asSet(self):
        return UMLSet([self])
    
    def oclIsKindOf(self,t):
        return isinstance(self,t)
    
    def isTypeOf(self,t):
        return type(self)==type(t)
    
class UMLCollection:
    def __init__(self,items=None,frozen=0):
        if not items:
            self.items=[]            
        else:
            self.items=copy.copy(items)
        self.__frozen__=frozen
        
    def __getitem__(self,key):
        if type(key)==type(slice(0,0)):
            return self.items[key.start:key.stop]
        else:
            return self.items[key]

    def __getattr__(self,attr):
        # shorthand for collect page 6-71
        if attr[:2]=="__" or (self.items and not hasattr(self.items[0],attr)):
            raise AttributeError
        result=UMLBag()
        if len(self.items)>1:
            for v in self.items:
                result.append(getattr(v,attr))
            return result
        else:
            return getattr(self.items[0],attr)
            
    
    def sort(self,func):
        self.items.sort(func)
        
    def __add__(v1,v2):
        self.items=v1.items+v2.items
            
    def __setitem__(self,key,items):
        if self.__frozen__:
            raise "Updating a frozen collection"
        self.items[key]=items
    
    def remove(self,items):
        if self.__frozen__:
            raise "Updating a frozen collection"
        self.items.remove(items)

    def __len__(self):
        return len(self.items)

    def __getstate__(self):
        return {"items":copy.copy(self.items)}

    def __setstate__(self,state):
        self.items=state["items"]

    def __repr__(self):
        return str(self.__dict__.get('items',[]))

    # OCL-like memebers

    def size(self):
        return len(self.items)

    def includes(self,o):
        return o in self.items

    def excludes(self,o):
        return not self.includes(o)

    def count(self,o):
        c=0
        for x in self.items:
            if x==o:
                c=c+1
        return c

    def includesAll(self,c):
        for o in c:
            if o not in self.items:
                return 0
        return 1

    def excludesAll(self,c):
        for o in c:
            if o in self.items:
                return 0
        return 1

    def select(self,f):
        result=UMLSet()
        for v in self.items:
            if f(v):
                result.append(v)
        return result

    def reject(self,f):
        result=UMLSet()
        for v in self.items:
            if not f(v):
                result.append(v)
        return result

    def collect(self,f):
        result=UMLBag()
        for v in self.items:
            result.append(f(v))
        return result

    def isEmpty(self):
        return len(self.items)==0

    def nonEmpty(self):
        return not self.isEmpty()
    
    def sum(self):
        r=0
        for o in self.items:
            r=r+o
        return o
    
    def forAll(self,f):
        if not self.items or not inspect.getargspec(f)[0]:
            return 1

        nargs=len(inspect.getargspec(f)[0])
        if inspect.getargspec(f)[3]:
            nargs=nargs-len(inspect.getargspec(f)[3])
            
        assert(nargs>0)
        nitems=len(self.items)
        index=[0]*nargs
        
        while 1:
            args=[]
            for x in index:
                args.append(self.items[x])
            if not apply(f,args):
                return 0
            c=len(index)-1
            index[c]=index[c]+1
            while index[c]==nitems:
                index[c]=0
                c=c-1
                if c<0:
                    return 1
                else:
                    index[c]=index[c]+1 
                if index[c]==nitems-1:
                    c=c-1

    def exist(self,f):
        if not self.items or not inspect.getargspec(f)[0]:
            return 0

        nargs=len(inspect.getargspec(f)[0])
        if inspect.getargspec(f)[3]:
            nargs=nargs-len(inspect.getargspec(f)[3])
            
        assert(nargs>0)
        nitems=len(self.items)
        index=[0]*nargs
        while 1:
            args=[]
            for x in index:
                args.append(self.items[x])
            if apply(f,args):
                return 1
            c=len(index)-1
            index[c]=index[c]+1
            while index[c]==nitems:
                index[c]=0
                c=c-1
                if c<0:
                    return 0
                else:
                    index[c]=index[c]+1 
                if index[c]==nitems-1:
                    c=c-1
                    
class UMLBag(UMLCollection):
    def insert(self,v):
        self.append(v)
        
    def append(self,v):
        if self.__frozen__:
            raise "Updating a frozen collection"
        self.items.append(v)

class UMLSequence(UMLCollection):
    def insert(self,v):
        self.append(v)
        
    def append(self,v):
        if self.__frozen__:
            raise "Updating a frozen collection"
        for i in range(len(self.items)):
            if v<self.items[i]:
                self.items=self.items[:i]+[v]+self.items[i:]
                return
        self.items.append(v)
        
class UMLSet(UMLCollection):
    def insert(self,v):
        self.append(v)
        
    def append(self,v):
        if self.__frozen__:
            raise "Updating a frozen collection"
        if v not in self.items:
            self.items.append(v)
            
class UMLAssociationEnd(UMLSet):
    def __init__(self,value,parent,name,mm):
        self.__name__=name
        self.__mm__=mm
        self.parent=parent
        UMLSet.__init__(self,frozen=mm[5])

        for v in value:
            self.append(v)

    
    def __setstate__(self,state):
        #print state
        self.parent=state["parent"]
        self.__mm__=state["__mm__"]
        self.__name__=state["__name__"]
        self.items=state["items"]

    def append(self,v):
        if self.__frozen__==1:
            raise "Appending a frozen association end"
        if v not in self.items:
            if type(v)!=types.InstanceType and isinstance(v,UMLClass):
                raise WFRException("An associationEnd cannot contain",v)
                
            (mmtype,multiplicity,otherRole,otherMultiplicity,qualifier, frozen)=self.__mm__
            
            self.items.append(v)

            if otherRole and self.parent not in v.__dict__[otherRole].items:
                v.__dict__[otherRole].items.append(self.parent)

    add=append
    insert=append
    
    def remove(self,item):
        if self.__frozen__:
            raise "Updating a frozen association end"
        if item in self.items:
            (mmtype,multiplicity,otherRole,otherMultiplicity,qualifier, frozen)=self.__mm__
            if otherRole:
                item.__dict__[otherRole].items.remove(self.parent)
        self.items.remove(item)

    def __getstate__(self):
        state={}
        toSave=[]
        for p in self.items:
            toSave.append(p)
        state['__mm__']=self.__mm__
        state['__name__']=self.__name__
        state['parent']=self.parent
        state['items']=toSave
        return state



class UMLQSet(UMLCollection):
    def __init__(self,items=None,frozen=0):
        if not items:
            self.items={}            
        else:
            self.items=copy.copy(items)
        self.__frozen__=frozen
        
    def __getitem__(self,key):
        if type(key)==type(slice(0,0)):
            return self.items.values()[key.start:key.stop]
        else:
            return self.items[key]

    def __iter__(self):
        return iter(self.items.values())

    def __getattr__(self,attr):
        # shorthand for collect page 6-71
        if attr[:2]=="__" or (self.items and not hasattr(self.items.values()[0],attr)):
            raise AttributeError
        result=UMLBag()
        if len(self.items)>1:
            for v in self.items.values():
                result.append(getattr(v,attr))
            return result
        else:
            return getattr(self.items.values()[0],attr)
                
    def __repr__(self):
        return str(self.__dict__.get('items',{}))

class UMLQAssociationEnd(UMLQSet):
    def __init__(self,value,parent,name,mm):
        self.__name__=name
        self.__mm__=mm
        self.parent=parent
        UMLQSet.__init__(self,frozen=mm[5])

        for v in value.keys():
            self.items[v]=value[v]
    
    def __setstate__(self,state):
        #print state
        self.parent=state["parent"]
        self.__mm__=state["__mm__"]
        self.__name__=state["__name__"]
        self.items=state["items"]

    def __setitem__(self,key,v):
        (mmtype,multiplicity,otherRole,otherMultiplicity,qualifier, frozen)=self.__mm__
        
        if self.__frozen__:
            raise "Updating a frozen collection"

        if otherRole and self.parent not in v.__dict__[otherRole].items:
                v.__dict__[otherRole].items.append(self.parent)

            
        self.items[key]=v
        
    def __contains__(self, v):
        return v in self.items.values()
    
    def __delitem__(self,key):
        item=self.items[key]
        del self.items[key]
        (mmtype,multiplicity,otherRole,otherMultiplicity,qualifier, frozen)=self.__mm__
        if otherRole:
            item.__dict__[otherRole].items.remove(self.parent)
        
    def remove(self,item):
        toDelete=None
        for k in self.items.keys():
            if self.items[k]==item:
                toDelete=k
                break
        if toDelete:
            del self[toDelete]