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

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.UndoRedo.unittests.testLayerManager import testLayerManager as UndoRedoTestLayerManager


class testLayerManager(UndoRedoTestLayerManager):

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

import unittest
from smw.metamodel import UML14 as metamodel
#from LayerManager import LayerManager
from smw.scw.CodeGen.SfiManager import SfiManager
from smw.scw.UndoRedo.unittests.testSfiManager import testSfiManager as UndoRedoTestSfiManager
import os
import os.path
import sys
from smw.scw.py2uml import *
import popen2

from smw.io import *


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

    def setUp(self):
        self.sMan=obj2test


    def testGenerateCode(self):
        self.sMan.setUp()
        project1 = self.sMan.newProject("testproject1")
        returnv = self.sMan.generateCode(os.getcwd())

        self.assert_(os.path.isdir("testproject1"), "Error in generate code: the directory package was not created.")

        pu = py2uml()
        py2uml.convert(pu,"testproject1","testproject1.iml") # we have saved testproject1.iml file

        popen2.popen2("rm -r testproject1")
        
        
        self.sMan.setUp()
        some=self.sMan.loadProject("testproject1.iml")
        self.assert_(self.sMan.currentProject().name == "testproject1", "Failure in generateCode: proper project was not loaded back.")

        popen2.popen2("rm testproject1.iml")

        self.assert_(isinstance(returnv,metamodel.Model) and returnv.name == project1.name, "Failure. correct return value was not given back.")
        elem = self.sMan.layerManager().returnElements(self.sMan.currentProject())


        # tests for special cases:
        # no current project.
        self.sMan.setUp()
        returnv = self.sMan.generateCode(os.getcwd())
        self.assert_(returnv,'No return value from failed code generation')
        self.assert_(isinstance(returnv,str) , "Didn't get a string from failed code generation.")

        # the given path is invalid.
        self.sMan.setUp()
        returnv = self.sMan.generateCode("nonexistingdir")
        
        self.assert_(returnv, "No return value from failed code generation")
        self.assert_(isinstance(returnv,str), "Didn't get a string from failed code generation.")

        # path parameter is not given.
        self.sMan.setUp()
        project1 = self.sMan.newProject("testproject2")
        returnv = self.sMan.generateCode()
        self.assert_(isinstance(returnv,metamodel.Model) and returnv.name == project1.name , "Failure in generating code without path parameter.")

       #  popen2.popen2("rm -r testproject2")

        self.sMan.setUp()
        project1=self.sMan.newProject("testProject2")
        self.sMan.newClass()
        self.sMan.newOperation()


        saveModel("testi.iml",self.sMan.currentProject())
        

        returnv =  self.sMan.generateCode()
        self.assert_(isinstance(returnv,metamodel.Model),"Failed to generate code ...")
        popen2.popen2("rm testi.iml")
        # test with path that the user doesn't have write rights
        self.sMan.setUp()
        p=self.sMan.newProject()
        c1=self.sMan.newClass()    
        returnv=self.sMan.generateCode("/usr/lib/python2.2/")
        self.assert_(returnv,"no return value from failing code generation")
        self.assert_(isinstance(returnv,str),"didn't receive string from failing code generation")

        # test that no code is generated from project which violates the well-formed rules
        self.sMan.setUp()
        p=self.sMan.newProject()
        c1=self.sMan.newClass()
        self.sMan.focusOnElement(p)
        c2=self.sMan.newClass()
        g1=self.sMan.newGeneralization(c1,c2)
        self.assert_(g1,'failed to create generalization')
        g2=metamodel.Generalization()
        g2.child=c1
        g2.parent=c2
        g2.namespace=p
        try:
            p.isWellFormedRecursive()
            self.fail('wfr not violated')
        except:
            pass

            
        rv=self.sMan.generateCode()

        self.assert_(rv,"Didn't get a return value from failing code generation")

        # self.assert_(isinstance(rv,str),"Didn't get a string from failing code generation")
        # rv is not a string...some error message ?
        # test that the code is generated only if the model is changed
        # test for timestamp

        self.sMan.setUp()
        p=self.sMan.newProject('testProject')
        self.assert_(p,'project was not generated')
        self.assert_(self.sMan.codeGenTimestamp['testProject']==0,\
                     'wrong timestamp')
        code=self.sMan.generateCode()
        self.assert_(code,'None was returned')
        self.assert_(self.sMan.codeGenTimestamp['testProject']>0,\
                     'wrong timestamp, should be > 0')
        code=self.sMan.generateCode()
        self.assert_(isinstance(code,str),'string was not returned')
        c=self.sMan.newClass()
        self.assert_(c,'class was not generated')
        code=self.sMan.generateCode()
        self.assert_(code,'None was returned')
        self.assert_(self.sMan.codeGenTimestamp['testProject']>0,\
                     'wrong timestamp, should be > 0')

        # test for timestamp
        
    def testIsCodeGenerated(self):
        self.sMan.setUp()
        p=self.sMan.newProject()
        self.assert_(not self.sMan.isCodeGenerated(),'returned true when there is no code')
        for x in range(10):
            p=self.sMan.newPackage()
            self.assert_(p,'class was not generated')
            self.assert_(not self.sMan.isCodeGenerated(),'returned true when there is no code')
            code=self.sMan.generateCode()
            self.assert_(code,'None returned')
            self.assert_(self.sMan.isCodeGenerated(),'returned false when there is code')
            
            


    def testNewProjectCodeGen(self):
        # test for the timestamp 
        self.sMan.setUp()
        p=self.sMan.newProject()
        self.assert_(self.sMan.codeGenTimestamp.has_key(p.name),\
                     'Project is not in the dictionary')
        self.assert_(self.sMan.codeGenTimestamp[p.name]==0,'wrong value')

    def testRenameProjectCodeGen(self):
        # tests for timestamp
        self.sMan.setUp()
        p=self.sMan.newProject('oldname')
        self.assert_(self.sMan.codeGenTimestamp.has_key('oldname'),\
                     'old name not found ')
        v=self.sMan.codeGenTimestamp['oldname']
        n=self.sMan.renameProject(p.name,'newname')
        self.assert_(n,'None was returned')
        self.assert_(self.sMan.codeGenTimestamp.has_key('newname'),\
                     'new name not found ')
        self.assert_(self.sMan.codeGenTimestamp['newname']==v,'wrong value')
        self.assert_(not self.sMan.codeGenTimestamp.has_key('oldname'),\
                     'old name found ')
    def testDeleteProjectCodeGen(self):
        # tests for timestamp
        self.sMan.setUp()
        p=self.sMan.newProject('name')
        self.assert_(self.sMan.codeGenTimestamp.has_key('name'),\
                     'name not found ')
        d=self.sMan.deleteProject(p.name)
        self.assert_(d,'delete failed')
        self.assert_(not self.sMan.codeGenTimestamp.has_key('name'),\
                     'name is still in the dictionary' )
    
    def testLoadProjectCodeGen(self):
        self.sMan.setUp()
        p=self.sMan.newProject()
        self.assert_(p,'newProject failed')
        s=self.sMan.saveProject()
        self.assert_(s,'save failed')
        l=self.sMan.loadProject(p.name+'.iml')
        self.assert_(l,'load failed')
        self.assert_(self.sMan.codeGenTimestamp.has_key(p.name),\
                     'name not found ')
        self.assert_(self.sMan.codeGenTimestamp[p.name]==0,'wrong value')
    def testRenameElementCodeGen(self):
        self.sMan.setUp()
        self.sMan.newProject()
        c1=self.sMan.newClass()

        self.sMan.setApplication(c1)

        x=c1.taggedValue.select(lambda x: x.name=="application")
        self.assert_(len(x)==1,"Didn't find the application tag")
        s=string.split(x[0].dataValue,"import ")[1]
        s=string.split(s,self.sMan.returnCode())
        s=s[0]
        

        self.assert_(s==c1.name,"class name was not found from application tag")

        self.sMan.renameElement(c1,"newName")

        self.assert_(c1.name=="newName","renaming class failed")
        x=c1.taggedValue.select(lambda x: x.name=="application")
        self.assert_(len(x)==1,"Didn't find the application tag")
        print x[0].dataValue
        s=string.split(x[0].dataValue,"import ")[1]
        s=string.split(s,self.sMan.returnCode())[0]
        
        self.assert_(s==c1.name,"class name was not found from application tag after renaming the class")        
        
        


    def testSetApplication(self):
        self.sMan.setUp()
        someClass=metamodel.Class()
        ApplicationClass=self.sMan.setApplication(someClass)

        self.assertEqual(ApplicationClass,None,"Was able to set an outside class as application class in project")

        project=self.sMan.newProject()
        ApplicationClass=self.sMan.setApplication(someClass)
        self.assertEqual(ApplicationClass,None,"Was able to set an outside class as application class in project")

        someClass=self.sMan.newClass()
        ApplicationClass=self.sMan.setApplication(someClass)

        self.assertEqual(ApplicationClass,someClass,"Failed to set a class as application class")

        classList=[]

        for i in range(10):
            self.sMan.focusOnElement(project)
            tempClass=self.sMan.newClass()
            ApplicationClass=self.sMan.setApplication(tempClass)
            classList.append(ApplicationClass)
            self.assertEqual(ApplicationClass,tempClass,"Failed to set a class as application class")
            if i != 0:
                tags=[]
                for x in classList[i-1].taggedValue:
                    tags.append(x.name)

                self.assert_("application" not in tags, "Failed to remove previous tag")
            
        

        # self.assertEqual(len(ApplicationClass.taggedValue), 1, "Failed, application tag is not found in application class")

        list=[]
        tag=None
        for x in ApplicationClass.taggedValue:
            list.append(x.name)
            if x.name=="application":
                tag=x
            
        self.assert_("application" in list, "Failed, application tag was not named right")

        self.assertNotEqual(tag.dataValue,"","Application tag doesn't hold any script code")



    def testExecute(self):
        self.sMan.setUp()
        self.sMan.newProject()
        class1=self.sMan.newClass()
        self.sMan.setApplication(class1)
        temp=self.sMan.execute()
        self.assertEqual(temp,None,"Failure, should return None when trying to execute before code generation")
      
        #paketin oikeellisuus...

    def testRunTest(self):


        self.sMan.setUp()
        project = self.sMan.newProject("testProject11")
        layer1=self.sMan.newLayer()
        self.sMan.focusOnElement(layer1)
        pack1=self.sMan.newPackage("pack1")
        class1=self.sMan.newClass("testi")
        testClass=self.sMan.layerManager().getTestClient(class1)
        self.sMan.focusOnElement(pack1)

        self.assert_(not self.sMan.runTest([testClass]),"Should return none")

        self.assertEqual(self.sMan.runTest([class1]),None,"Should return none when trying to run with norm class")
        
        returnv=self.sMan.generateCode(os.getcwd())

        self.assertNotEqual(self.sMan.runTest([testClass]),None,"Should run the test after code generation")


##        TEE TESTI MISSÄ LAYER/PACKAGE ON "all tests passed" JA SITTEN TEE FAILAAVA TOTEUTUS TESTIIN--> LAYER/PACKAGE on "some tests failed"

        popen2.popen2("rm -r testProject11")

        
        

    def testRunAllTests(self):
        self.sMan.setUp()
        project=self.sMan.newProject("testProject22")
        pack1=self.sMan.newPackage()
        class1=self.sMan.newClass()
        self.sMan.focusOnElement(pack1)
        class2=self.sMan.newClass()
        method1=self.sMan.newMethod()
        self.sMan.focusOnElement(pack1)       
        class3=self.sMan.newClass()

        testClass1=self.sMan.layerManager().getTestClient(class1)
        testClass2=self.sMan.layerManager().getTestClient(class2)
        testClass3=self.sMan.layerManager().getTestClient(class3)


        self.assert_(not self.sMan.runAllTests(),"Should return None. code is generated")


        ## ERROR IN UML2PY
        returnv=self.sMan.generateCode(os.getcwd())

        self.assertNotEqual(self.sMan.runAllTests(),None,"Should run the tests after code generation")

        popen2.popen2("rm -r testProject22") 

    def testUpdateModelTags(self):
        self.sMan.setUp()
        proj=self.sMan.newProject('newProject')
        class1=self.sMan.newClass()
        self.sMan.focusOnElement(proj)
        layer1=self.sMan.newLayer()
        self.sMan.focusOnElement(layer1)
        class2=self.sMan.newClass()
        self.sMan.focusOnElement(layer1)
        pack1=self.sMan.newPackage()
        class3=self.sMan.newClass()

        c=self.sMan.generateCode(os.getcwd())
        self.assert_(c,'No code generated')
        res=self.sMan.runTest([self.sMan.layerManager().getTestClient(class3)])
        self.assert_(res,'no result')
        for x in pack1.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="all tests passed","Should have all tests passed in correctness tag")
                
        for x in layer1.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="undefined","shouldn't change the tag at this point")
        for x in proj.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="undefined","shouldn't change the tag at this point")

        self.sMan.runTest([self.sMan.layerManager().getTestClient(class1)])
        for x in pack1.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="all tests passed","Should have all tests passed in correctness tag")
        for x in layer1.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="undefined","shouldn't change the tag at this point")
        for x in proj.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="undefined","shouldn't change the tag at this point")

        self.sMan.runTest([self.sMan.layerManager().getTestClient(class2)])
        for x in pack1.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="all tests passed","Should have all tests passed in correctness tag")
        for x in layer1.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="all tests passed","Should have all tests passed in correctness tag")
        for x in proj.taggedValue:
            if x.name=="correctness":
                self.assert_(x.dataValue=="all tests passed","Should have all tests passed in correctness tag")
        popen2.popen2("rm -r newProject")                    

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]