Menu
▾
▴
pymerase-cvs-commit — CVS Commits to Pymerase Project
You can subscribe to this list here.
| 2002 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
|
Oct
|
Nov
|
Dec
(57) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2003 |
Jan
(44) |
Feb
(151) |
Mar
(131) |
Apr
(171) |
May
(125) |
Jun
(43) |
Jul
(26) |
Aug
(19) |
Sep
(10) |
Oct
|
Nov
(4) |
Dec
(28) |
| 2004 |
Jan
(134) |
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
|
Oct
|
Nov
|
Dec
|
|
From: <de...@us...> - 2004-01-16 01:22:09
|
Update of /cvsroot/pymerase/pymerase/tests
In directory sc8-pr-cvs1:/tmp/cvs-serv7382
Modified Files:
TestSchool.py
Log Message:
Add tests for new-style attribute access
Index: TestSchool.py
===================================================================
RCS file: /cvsroot/pymerase/pymerase/tests/TestSchool.py,v
retrieving revision 1.11
retrieving revision 1.12
diff -C2 -d -r1.11 -r1.12
*** TestSchool.py 18 Dec 2003 00:11:28 -0000 1.11
--- TestSchool.py 16 Jan 2004 01:22:06 -0000 1.12
***************
*** 435,440 ****
finally:
s.close()
-
def testOneToOneUpdate(self):
"""Make sure that set replaces not appends with a one to one links
--- 435,467 ----
finally:
s.close()
+ def testNewAttributeAccess(self):
+ """test new-style python attribute access
+ implementation by Luis Rodrigo Gallardo Cruz
+ """
+ import school
+ school.moduleReload()
+ s = schoo.DBSession(host, datbase)
+
+ try:
+ guiseppe = s.Staff()
+ guiseppe.Uid = "0014"
+ guiseppe.GivenName = "Guiseppe"
+ guiseppe.FamilyName = "Gallard"
+ guiseppe.JobDescription = "accountant"
+ guiseppe.commit()
+
+ givenNameQuery = "%s = 'Guiseppe'" % (givenNameFieldName)
+ guiseppe_list = s.getObjectsWhere(s.Staff, givenNameQuery)
+ self.failUnless(len(guiseppe_list) == 1)
+ guiseppe_saved = guiseppe_list[0]
+
+ self.failUnless(guiseppe.Uid == guiseppe_saved.getGivenName())
+ self.failUnless(guiseppe.GivenName == guiseppe_saved.getGivenName())
+ self.failUnless(guiseppe.FamilyName == guiseppe_saved.getFamilyName())
+ self.failUnless(guiseppe.JobDescription == guiseppe_saved.getJobDescription())
+ finally:
+ s.close()
+
def testOneToOneUpdate(self):
"""Make sure that set replaces not appends with a one to one links
***************
*** 602,605 ****
--- 629,633 ----
suite.addTest(CreateSchoolTestCases("testReadManyToManyLink"))
suite.addTest(CreateSchoolTestCases("testOneToOneInsert"))
+ suite.addTest(CreateSchoolTestCases("testNewAttributeAccess"))
suite.addTest(CreateSchoolTestCases("testOneToOneUpdate"))
suite.addTest(CreateSchoolTestCases("testManyToOneInsert"))
|
|
From: <de...@us...> - 2004-01-16 00:51:34
|
Update of /cvsroot/pymerase/pymerase/pymerase/output
In directory sc8-pr-cvs1:/tmp/cvs-serv2385
Modified Files:
CreateJava.py
Log Message:
more progress at converting squashed sigmoid velocity templates
Index: CreateJava.py
===================================================================
RCS file: /cvsroot/pymerase/pymerase/pymerase/output/CreateJava.py,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** CreateJava.py 18 Dec 2003 00:32:03 -0000 1.1
--- CreateJava.py 16 Jan 2004 00:51:30 -0000 1.2
***************
*** 90,97 ****
class JavaTemplate(Template):
! def __init__(self):
Template.__init__(self)
#######################################
# Output Translater Interface
--- 90,134 ----
class JavaTemplate(Template):
! def __init__(self, classMetaInfo, TranslatorName):
Template.__init__(self)
+ self.classMetaInfo = classMetaInfo
+ self.TranslatorName = TranslatorName
+ def ClassName(self):
+ return self.classMetaInfo.getName(self.TranslatorName)
+
+ def ExtendsClause(self):
+ if not self.classMetaInfo.isRootClass():
+ baseClasses = self.classMetaInfo.getBaseClassNames(self.TranslatorName)
+ return "extends " + string.join(baseClasses, ", ")
+ else:
+ return ""
+
+ def writeDebugPrint(self, indent):
+ c =[]
+ c +=['/**']
+ c +=[' * Prints a string represenation of this class to aid in debugging']
+ c +=[' */']
+ c +=['public void debugPrint()']
+ c +=['{']
+ c +=[' System.out.println("class %(ClassName())s");' % (self)]
+ c +=[' debugDumpAttributes();']
+ c +=[' System.out.println();']
+ c +=['}']
+ c +=['']
+ c +=['']
+ c +=['protected void debugDumpAttributes()']
+ c +=['{']
+ if not self.classMetaInfo.isRootClass():
+ c +=[' super.debugDumpAttributes();']
+ else:
+ c +=[' System.out.println(" _id: " + _id);']
+ for attribute in self.classMetaInfo.getAttributes():
+ name = attribute.getName(self.TranslatorName)
+ c +=[' System.out.println(" '+name+': " +'+ name + ');']
+ c += ['}']
+ return string.join(addIndentToStrings(indent, c), os.linesep)
+
#######################################
# Output Translater Interface
***************
*** 100,142 ****
"""
c = []
! c += ["/** "]
! c += [" * Create a new %(ClassName)s"]
! c += [" *"]
! c += [" * All collections will be initialized (as empty)."]
! c += [" */"]
! c += [""]
! c += ["public %(ClassName)s()"]
! c += ["{"]
! if not classMetaInfo.isBaseClass():
! c += [" super();"]
! c += [""]
! c += ["%(ClasInitializer)s"]
! c += [""]
! c += ["/**"]
! c += [" * Create a new %(ClassName)s with all fields initialized."]
! c += [" */"]
! c += ["%(DefaultConstructor)s"]
! c += [""]
! c += ["/**"]
! c += [" * Prints a string represenation of this class to aid in deubbing"]
! c += [" */"]
! c += ["public void debugPrint()"]
! c += ["{"]
! c += [" System.out.println(class %(ClassName)s)"]
! c += [" debugDumpAttributes();"]
! c += [" System.out.println();"]
! c += ["}"]
! c += [""]
! c += ["protected void de"]
! c += [""]
! c += [""]
! c += [""]
! c += [""]
! c += [""]
! c += [""]
! c += [""]
! c += [""]
! c += [""]
! c += [""]
--- 137,204 ----
"""
c = []
! c += ['/** ']
! c += [' * Create a new %(ClassName())s']
! c += [' *']
! c += [' * All collections will be initialized (as empty).']
! c += [' */']
! c += ['']
! c += ['public %(ClassName())s %(ExtendsClause())s']
! c += ['{']
! c += [' #writeNoArgCtor']
! if len(classMetaInfo.getAttributes()) > 0:
! c += [' #writeArgCtor']
! c +=['']
! c +=[' /**']
! c +=[' * Getter / Setter Pairs']
! c +=[' */']
! c +=['']
! c +=['']
! c +=[' /**']
! c +=[' * Collection adder/removers']
! c +=[' */']
! c +=['']
! c +=['']
! c +=[' /**']
! c +=[' * Debugging']
! c +=[' */']
! c +=['%(writeDebugPrint(2))s']
! c +=['']
! c +=[' /**']
! c +=[' * Attributes']
! c +=[' */ ']
! #for attribute in classMetaInfo.getAttributes():
! # c += [' %()']
! c +=['']
! c +=[' /**']
! c +=[' * Extra attributes to hold the primary key of the different object']
! c +=[' * references.']
! c +=[' */']
! c +=['']
! c +=['']
! c +=[' /**']
! c +=[' * Extra Object Relational Bridge (OJB) attributes for mapping back']
! c +=[' * to classses which have a 1:N relation with this specific class.']
! c +=[' */']
! c +=['']
! c +=['']
! c +=[' /**']
! c +=[' * Primary Key in database']
! c +=[' */ ']
! #c +=[' protected int _id;']
! c +=['};']
!
! template_engine = JavaTemplate(classMetaInfo, None)
!
! template = string.join(c, os.linesep)
! destination_filename = os.path.join(destination,
! template_engine.ClassName()+".java")
! template_engine.writeFile(template, destination_filename)
! return
!
! c += ['/**']
! c += [' * Create a new %(ClassName)s with all fields initialized.']
! c += [' */']
! c += ['%(DefaultConstructor)s']
! c += ['']
***************
*** 147,158 ****
os.mkdir(destination)
elif not os.path.isdir(destination):
! msg = "PATH(%s) is not a directory!" % (destination)
raise ValueError(msg)
package_information = []
! for t in tables:
try:
! package_information.append(writeClass(destination, t))
except NotImplementedError, e:
! warn("Skipping %s" % ( t.getName() ), DebugWarning)
--- 209,220 ----
os.mkdir(destination)
elif not os.path.isdir(destination):
! msg = 'PATH(%s) is not a directory!' % (destination)
raise ValueError(msg)
package_information = []
! for class_info in parsedInput:
try:
! package_information.append(writeClass(destination, class_info))
except NotImplementedError, e:
! warn('Skipping %s' % ( t.getName() ), DebugWarning)
|
|
From: <de...@us...> - 2004-01-16 00:50:05
|
Update of /cvsroot/pymerase/pymerase/pymerase
In directory sc8-pr-cvs1:/tmp/cvs-serv2166
Modified Files:
ClassMembers.py
Log Message:
Add support for tracking Public/Private/Protected attributes
Index: ClassMembers.py
===================================================================
RCS file: /cvsroot/pymerase/pymerase/pymerase/ClassMembers.py,v
retrieving revision 1.28
retrieving revision 1.29
diff -C2 -d -r1.28 -r1.29
*** ClassMembers.py 10 Sep 2003 02:07:13 -0000 1.28
--- ClassMembers.py 16 Jan 2004 00:50:02 -0000 1.29
***************
*** 210,213 ****
--- 210,217 ----
return self.config.getNameMangler(translatorName).createAppender(self.name)
+ ATTRIBUTE_PUBLIC = 0
+ ATTRIBUTE_PROTECTED = 1
+ ATTRIBUTE_PRIVATE = 2
+
class ClassAttribute(ModelElement):
"""Stores information about an attribute from the xml definition file
***************
*** 221,224 ****
--- 225,229 ----
self.__primaryKey = 0
self.__foreignKey = 0
+ self.__access = ATTRIBUTE_PUBLIC
self.__indexed = 0
***************
*** 281,284 ****
--- 286,321 ----
return (self.__primaryKey or self.__foreignKey)
+ def setPublicAccess(self):
+ """Indicate attribute has public access
+ """
+ self.__access = ATTRIBUTE_PUBLIC
+
+ def isPublicAccess(self):
+ """Does attribute has public access
+ """
+ return self.__access == ATTRIBUTE_PUBLIC
+
+ def setProtectedAccess(self):
+ """Indicate attribute has protected access
+ """
+ self.__access = ATTRIBUTE_PROTECTED
+
+ def isProtectedAccess(self):
+ """Does attribute has protected access
+ """
+ return self.__access == ATTRIBUTE_PROTECTED
+
+ def setPrivateAccess(self):
+ """Indicate attribute has private access
+ """
+ self.__access = ATTRIBUTE_PRIVATE
+
+ def isPrivateAccess(self):
+ """Does attribute has private access
+ """
+ return self.__access == ATTRIBUTE_PRIVATE
+ # end class attribute
+
+
def createAssociation(pymeraseConfig, thisEnd, otherEnd, associationName=None, associationUUID=None):
"""Helper function to create association with provided associationEnds
***************
*** 315,318 ****
--- 352,356 ----
return association
+
class Association(ModelElement):
"""Describe the meta info regarding the between two objects
***************
*** 366,370 ****
firstEndName,
secondEndName)
!
class AssociationEnd(ModelElement):
"""Maintain meta information each end of an association.
--- 404,408 ----
firstEndName,
secondEndName)
!
class AssociationEnd(ModelElement):
"""Maintain meta information each end of an association.
***************
*** 389,392 ****
--- 427,431 ----
self.__multiplicity = None
self.__aggregation = 0
+ self.__access = ATTRIBUTE_PUBLIC
# things to make ER easier
|
|
From: <de...@us...> - 2004-01-16 00:49:19
|
Update of /cvsroot/pymerase/pymerase/tests/pymerase
In directory sc8-pr-cvs1:/tmp/cvs-serv2014
Modified Files:
TestClassMembers.py
Log Message:
added tests for isPublic/Private/Protected. Fixed some invalid tests
Index: TestClassMembers.py
===================================================================
RCS file: /cvsroot/pymerase/pymerase/tests/pymerase/TestClassMembers.py,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** TestClassMembers.py 10 Sep 2003 02:05:30 -0000 1.2
--- TestClassMembers.py 16 Jan 2004 00:49:16 -0000 1.3
***************
*** 17,21 ****
#from pymerase.util import NameMangling
!
class ClassMemberTestCases(unittest.TestCase):
--- 17,21 ----
#from pymerase.util import NameMangling
! TRANSLATOR=None
class ClassMemberTestCases(unittest.TestCase):
***************
*** 33,37 ****
# can we be named
me = ClassMembers.ModelElement(self.config, "testModelElement")
! self.failUnless(me.getName(None) == "testModelElement")
# does the friendly name default properly?
--- 33,37 ----
# can we be named
me = ClassMembers.ModelElement(self.config, "testModelElement")
! self.failUnless(me.getName(TRANSLATOR) == "testModelElement")
# does the friendly name default properly?
***************
*** 71,77 ****
# test naming utilities
! self.failUnless(me.getGetterName(None) == 'gettestModelElement')
! self.failUnless(me.getSetterName(None) == 'settestModelElement')
! self.failUnless(me.getAppenderName(None) == 'appendtestModelElement')
--- 71,77 ----
# test naming utilities
! self.failUnless(me.getGetterName(TRANSLATOR) == 'gettestModelElement')
! self.failUnless(me.getSetterName(TRANSLATOR) == 'settestModelElement')
! self.failUnless(me.getAppenderName(TRANSLATOR) == 'appendtestModelElement')
***************
*** 130,133 ****
--- 130,145 ----
self.fail("a key cannot be both a primary and foreign key")
+ # test accessors
+ # default is public access
+ self.failUnless(ca.isPublicAccess() and not ca.isProtectedAccess() and not ca.isPrivateAccess(), "default is public")
+ ca.setProtectedAccess()
+ self.failUnless(not ca.isPublicAccess() and ca.isProtectedAccess() and not ca.isPrivateAccess(), "should've been protected")
+ ca.setPrivateAccess()
+ self.failUnless(not ca.isPublicAccess() and not ca.isProtectedAccess() and ca.isPrivateAccess(), "should've been private")
+ ca.setPublicAccess()
+ self.failUnless(ca.isPublicAccess() and not ca.isProtectedAccess() and not ca.isPrivateAccess(), "should've been public")
+
+
+
def testAssociationEnd(self):
"""Test parts of an AssociationEnd that doesn't depend on being in an Association
***************
*** 136,145 ****
ae.setAttributeName('attribute')
! self.failUnless(ae.getAttributeName(None) == 'attribute')
cmi = ClassMembers.ClassMetaInfo(self.config, 'ClassMetaInfo')
ae.setType(cmi)
self.failUnless(ae.getType() == cmi)
! self.failUnless(ae.getClassName(None) == 'ClassMetaInfo')
self.failUnless(ae.getMultiplicity() is None)
--- 148,157 ----
ae.setAttributeName('attribute')
! self.failUnless(ae.getAttributeName(TRANSLATOR) == 'attribute')
cmi = ClassMembers.ClassMetaInfo(self.config, 'ClassMetaInfo')
ae.setType(cmi)
self.failUnless(ae.getType() == cmi)
! self.failUnless(ae.getClassName(TRANSLATOR) == 'ClassMetaInfo')
self.failUnless(ae.getMultiplicity() is None)
***************
*** 151,157 ****
self.failUnless(ae.isNavigable())
! self.failUnless(ae.getGetterName(None) == 'gettestAssociationEnd')
! self.failUnless(ae.getSetterName(None) == 'settestAssociationEnd')
! self.failUnless(ae.getAppenderName(None) == 'appendtestAssociationEnd')
--- 163,169 ----
self.failUnless(ae.isNavigable())
! self.failUnless(ae.getGetterName(TRANSLATOR) == 'gettestAssociationEnd')
! self.failUnless(ae.getSetterName(TRANSLATOR) == 'settestAssociationEnd')
! self.failUnless(ae.getAppenderName(TRANSLATOR) == 'appendtestAssociationEnd')
***************
*** 171,175 ****
A = ClassMembers.createAssociation(self.config, leftAE, rightAE, "ends")
! self.failUnless(A.getName(None) == "ends")
self.failUnless(len(A) == 2)
self.failUnless(leftAE.getAssociation() == A)
--- 183,187 ----
A = ClassMembers.createAssociation(self.config, leftAE, rightAE, "ends")
! self.failUnless(A.getName(TRANSLATOR) == "ends")
self.failUnless(len(A) == 2)
self.failUnless(leftAE.getAssociation() == A)
***************
*** 188,192 ****
A = ClassMembers.createAssociation(self.config, leftAE, rightAE)
! self.failUnless(A.getName(None) == 'leftAssociationEndrightAssociationEnd')
def testClassMetaInfo(self):
--- 200,204 ----
A = ClassMembers.createAssociation(self.config, leftAE, rightAE)
! self.failUnless(A.getName(TRANSLATOR) == 'leftAssociationEndrightAssociationEnd')
def testClassMetaInfo(self):
***************
*** 199,210 ****
cmi = ClassMembers.ClassMetaInfo(self.config, "testClassMetaInfo")
! testFilename = "/a/b/c/d"
! cmi.setFilename(testFilename)
self.failUnless(cmi.getFilename() == testFilename, "%s was not %s" % (cmi.getFilename(), testFilename) )
! self.failUnless(not cmi.getAbstract())
cmi.setAbstract(1)
! self.failUnless(cmi.getAbstract())
# FIXME: test adding an association end?
--- 211,223 ----
cmi = ClassMembers.ClassMetaInfo(self.config, "testClassMetaInfo")
! testPathname = "/a/b/c/d"
! testPath, testFilename = os.path.split(testPathname)
! cmi.setFilename(testPathname)
self.failUnless(cmi.getFilename() == testFilename, "%s was not %s" % (cmi.getFilename(), testFilename) )
! self.failUnless(not cmi.isAbstract())
cmi.setAbstract(1)
! self.failUnless(cmi.isAbstract())
# FIXME: test adding an association end?
***************
*** 213,232 ****
attrib2 = ClassMembers.ClassAttribute(self.config, 'attrib2')
! self.failUnless(len(cmi.getAttributes() == 0))
cmi.addAttribute(attrib1)
cmi.addAttribute(attrib2)
! self.failUnless(len(cmi.getAttributes() == 2))
! self.failUnless(cmi.getAttributeByName('attrib1') == attrib1)
! self.failUnless(len(cmi.getAttributeNames()) == 2)
! self.failUnless('attrib1' in cmi.getAttributeNames())
cmi.appendBaseClass(root1)
cmi.appendBaseClass(root2)
self.failUnless(root1 in cmi.getBaseClasses())
! self.failUnless('root1' in cmi.getBaseClassNames(None))
self.failUnless(root2 in cmi.getBaseClasses())
! self.failUnless('root2' in cmi.getBaseClassNames(None))
self.failUnless(len(cmi.getBaseClasses()) == 2)
! self.failUnless(len(cmi.getBaseClassNames()) == 2)
self.failUnless(not cmi.isRootClass())
--- 226,245 ----
attrib2 = ClassMembers.ClassAttribute(self.config, 'attrib2')
! self.failUnless(len(cmi.getAttributes()) == 0)
cmi.addAttribute(attrib1)
cmi.addAttribute(attrib2)
! self.failUnless(len(cmi.getAttributes()) == 2)
! self.failUnless(cmi.getAttributeByName('attrib1', TRANSLATOR) == attrib1)
! self.failUnless(len(cmi.getAttributeNames(TRANSLATOR)) == 2)
! self.failUnless('attrib1' in cmi.getAttributeNames(TRANSLATOR))
cmi.appendBaseClass(root1)
cmi.appendBaseClass(root2)
self.failUnless(root1 in cmi.getBaseClasses())
! self.failUnless('root1' in cmi.getBaseClassNames(TRANSLATOR))
self.failUnless(root2 in cmi.getBaseClasses())
! self.failUnless('root2' in cmi.getBaseClassNames(TRANSLATOR))
self.failUnless(len(cmi.getBaseClasses()) == 2)
! self.failUnless(len(cmi.getBaseClassNames(TRANSLATOR)) == 2)
self.failUnless(not cmi.isRootClass())
***************
*** 235,240 ****
self.failUnless(cmi.getRootClass() == root1)
! self.failUnless(cmi.getBasePrimaryKeyName(None) == 'root1Attrib_pk')
! self.failUnless(smi.getForeignKeyName(None) == 'testClassMetaInfo_fk')
def suite():
--- 248,253 ----
self.failUnless(cmi.getRootClass() == root1)
! self.failUnless(cmi.getBasePrimaryKeyName(TRANSLATOR) == 'root1_pk')
! self.failUnless(cmi.getForeignKeyName(TRANSLATOR) == 'testClassMetaInfo_fk')
def suite():
|
|
From: <de...@us...> - 2004-01-07 02:00:54
|
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)
|
|
From: <de...@us...> - 2004-01-07 02:00:52
|
Update of /cvsroot/pymerase/smw/smw/taco In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/taco Added Files: __init__.py Log Message: Imported version of SMW downloaded on 2003 Apr 14 --- NEW FILE: __init__.py --- """ SMW The System Modeling Workbench Copyright 2001,2002 by Ivan Porres ip...@ab... The System Modeling Workbench is a collection of tools for creating, editing and transforming software models. MODELER We recomend that you start using the SMW Modeler in order to get familiar with SMW. MODELS From the programmer's point of view, each supported modeling language is represented by a metamodel module. A metamodel module contains a Python class for each model element. These classes have the same attributes and associations with the same name as in the metamodel of the modeling language. Since the model elements are represented as Python classes, we can create a model by instantiating new objects and manipulating its associations. METAMODELS SMW provides the following metamodels Language Module UML 1.1 smw.metamodel.UML11 UML 1.3 smw.metamodel.UML13 UML 1.4 smw.metamodel.UML14 You should import the appropiate module, i.e.: from smw.metamodel import UML14 LICENSE This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. """ |
|
From: <de...@us...> - 2004-01-07 02:00:51
|
Update of /cvsroot/pymerase/smw/smw/testdriver
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/testdriver
Added Files:
DiagramEditorTester.py PropertyEditorTester.py __init__.py
pycov.py unittester.py
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: DiagramEditorTester.py ---
import unittest
import sys
from smw.metamodel.MetaMM import *
from smw.modeler import modelerApp
from smw.modeler.DiagramEditor import *
from smw.modeler.UML.UMLCoreEditor import *
import smw.modeler.Gestures
class FakeEvent:
def __init__(self,sX,sY):
self.sX=sX
self.sY=sY
class DiagramEditorTester:
def __init__(self,profile="UML14"):
smw=modelerApp.modelerApp()
smw.main(loop=0,args=["--profile",profile])
self.smw=smw
self.DEM=None
for e in smw.project.editorSet.editors():
if isinstance(e,DiagramEditorManager):
self.DEM=e
assert(self.DEM)
def getMainEditor(self):
self.smw.processEvents()
return self.DEM.subEditors[0]
def getCurrentEditor(self):
self.smw.processEvents()
return self.DEM.getCurrentEditor()
def testActionConnection(self,de,actions):
de.expossed()
for a in actions:
if not de.mainWindow.actions.isConnected(a,de):
raise("Something missing in activateActions: Action "+str(a)+" is not connected to editor "+str(de)+" after an expose event")
de.obscured()
for a in actions:
if de.mainWindow.actions.isConnected(a,de):
raise("Something wrong in obscured: Action "+str(a)+" is still connected to editor "+str(de)+" after an obscyre event")
def testCreateInside(self,de,containerA,others):
de.expossed()
de.selectAll()
de.deleteSelection()
h=de.mainWindow.actions.getHandler(containerA,de)
if not h:
raise "Unknown action",containerA
h()
container=de.currentGesture.onAdd( (300,50) )
for a in others:
h=de.mainWindow.actions.getHandler(a,de)
if not h:
raise "Unknown action",a
h()
o=de.currentGesture.doIt ( FakeEvent(320,60) )
assert(o)
print de.currentGesture
p=self.presentationsOfElement(o,de)[0]
self.smw.processEvents()
assert(container.isPart(o))
de.selectPresentation(p)
de.deleteSelection()
def testActionCombo(self,de,first,second,link,selfLink=1):
de.expossed()
h=de.mainWindow.actions.getHandler(first,de)
if not h:
raise "Unknown action",first
h()
firstE=de.currentGesture.onAdd((50,50))
firstP=self.presentationsOfElement(firstE,de)[0]
thirdE=de.currentGesture.onAdd((200,50))
thirdP=self.presentationsOfElement(thirdE,de)[0]
h=de.mainWindow.actions.getHandler(second,de)
if not h:
raise "Unknown action",second
h()
secondE=de.currentGesture.onAdd((150,150))
secondP=self.presentationsOfElement(secondE,de)[0]
h=de.mainWindow.actions.getHandler(link,de)
h()
linkE=de.currentGesture.onLink(firstP,secondP,[[50,50],[150,150]])
assert(linkE)
linkP=self.presentationsOfElement(linkE,de)[0]
assert(linkP.diagram==de.diagram)
link2E=de.currentGesture.onLink(thirdP,secondP,[[200,50],[150,150]])
assert(linkE)
link2P=self.presentationsOfElement(link2E,de)[0]
assert(link2P.diagram==de.diagram)
self.testCutCopyPaste(de)
self.testActionCombo2(de,firstE,secondE,thirdE,linkE)
#self.testCutCopyPaste(de)
de.selectAll()
de.deleteSelection()
if first==second and selfLink and not isinstance(linkE,Generalization) and not isinstance(linkE,Include) and not isinstance(linkE,Extend)\
and not isinstance(linkE,Stimulus):
h=de.mainWindow.actions.getHandler(first,de)
h()
firstE=de.currentGesture.onAdd((50,50))
firstP=self.presentationsOfElement(firstE,de)[0]
h=de.mainWindow.actions.getHandler(link,de)
h()
linkE=de.currentGesture.onLink(firstP,firstP,[[50,50],[55,55]])
assert(linkE)
linkP=self.presentationsOfElement(linkE,de)[0]
assert(linkP.diagram==de.diagram)
self.testActionCombo2(de,firstE,firstE,thirdE,linkE)
#self.testCutCopyPaste(de)
de.selectAll()
de.deleteSelection()
def testActionCombo2(self,de,firstE,secondE,thirdE,linkE):
self.testMoveCircle(firstE,de)
self.testHideAndDrop(linkE,de)
self.testDelete(linkE,de)
self.testDelete(firstE,de,testHideAfterDelete=0)
if firstE!=secondE:
self.testDelete(secondE,de,testHideAfterDelete=0)
self.testDelete(linkE,de)
self.testHideAndDrop(linkE,de)
self.testHideAndDrop(firstE,de)
self.testRelink(de,linkE,thirdE)
self.testRelink(de,linkE,secondE)
assert(len(self.presentationsOfElement(linkE,de))==0)
self.testDrop(linkE,de)
assert(len(self.presentationsOfElement(linkE,de)))
def testRelink(self,de,linkE,target):
pres,targetP=None,None
for p in linkE.presentation:
if isinstance(p,AbstractLinkView):
pres = p
break
for p in target.presentation:
if isinstance(p,QtPresentationElement) \
and not isinstance(p,TextQtPresentationElement):
targetP=p
if pres and targetP:
if pres.canConnectTo(target,1):
pres.connectTo(target,targetP,1)
def testAddPlaceAction(self,de,a):
h=de.mainWindow.actions.getHandler(a,de)
h()
if not isinstance(de.currentGesture,smw.modeler.Gestures.AddElementG):
raise "action "+str(a)+" does not activate AddElementG"
# create an element
e=de.currentGesture.doIt(FakeEvent(50,50))
if not isinstance(e,MetaMM.Element):
raise str(de.currentGesture.onAdd)+" does not return a model element"
if e.presentation.size()==0:
raise "Element "+str(e)+" does not have presentations!"
name1=e.name
e2=de.currentGesture.onAdd((150,150))
name2=e2.name
if name1==name2:
raise "Each element should have a different name. Action ",a
pe=self.presentationsOfElement(e,de)
if not pe:
raise "Element "+str(e)+" does not a have presentation in the diagram!"
self.testMove(e,de)
self.testHideAndDrop(e,de)
self.testDelete(e,de)
def testDelete(self,e,de,testHideAfterDelete=1):
for z in range(2):
self.smw.processEvents()
print "testDelete pass=",z
p=self.presentationsOfElement(e,de)[0]
de.selection.clear()
de.selectPresentation(p)
de.project.history.beginModifyCmd()
de.deleteSelection()
de.project.history.endModifyCmd()
print p
assert(not p.diagram)
de.project.history.undo()
assert(p.diagram==de.diagram)
de.project.history.redo()
assert(not p.diagram)
de.project.history.undo()
assert(p.diagram==de.diagram)
if testHideAfterDelete:
print "testHideAndDrop after delete and undo"
self.testHideAndDrop(e,de)
self.testMove(e,de)
def presentationsOfElement(self,e,de):
pe=[]
for p in e.presentation:
if p in de.diagram.content:
pe.append(p)
return pe
def testHideAndDrop(self,e,de):
for z in range(2):
pres=self.presentationsOfElement(e,de)
print "test HideAndDrop pass=",z
self.testMove(e,de)
de.selection.clear()
for p in pres:
de.selectPresentation(p)
self.testMove(e,de)
de.hideSelection()
assert(not p.diagram)
assert(p not in e.presentation)
assert(not len(self.presentationsOfElement(e,de)))
de.dropElement(60+100*z,60,e,clone=0,forceDropInDiagram=1)
if not len(self.presentationsOfElement(e,de)):
raise "Editor "+str(de)+" cannot accept drop "+str(e)
def testDrop(self,e,de):
de.dropElement(60,60,e,clone=0,forceDropInDiagram=1)
assert(len(self.presentationsOfElement(e,de)))
def testMove(self,e,de,x=0,y=0):
pass
def testMoveCircle(self,e,de):
y=30
while y<300:
x=30
while x<300:
self.testMove(e,de,x,y)
x=x+30
y=y+30
def testEditor(self,de,placeActions,actionCombos):
print "Testing editor ",de
assert(isinstance(de,DiagramEditor))
# focusOn is a protected
assert("focusOn" not in de.__dict__)
self.testActionConnection(de,placeActions)
de.expossed()
for a in placeActions:
self.testAddPlaceAction(de,a)
de.selectAll()
de.deleteSelection()
for c in actionCombos:
l=c[0]
for first in c[1]:
for second in c[2]:
print "Testing ",first,"-",l,"-",second
self.testActionCombo(de,first,second,l)
def testCutCopyPaste(self,de):
de.selectAll()
de.copy()
de.paste()
de.cut()
de.paste()
def testCreateDiagram(self,de,eAction,dMethod):
de.expossed()
h=de.mainWindow.actions.getHandler(eAction,de)
h()
if not isinstance(de.currentGesture,smw.modeler.Gestures.AddElementG):
raise "action "+str(eAction)+" does not activate AddElementG"
# create an element
e=de.currentGesture.onAdd((250,150))
newElement=dMethod(e)
self.smw.processEvents()
assert(newElement)
secondEditor=None
for p in newElement.presentation:
if isinstance(p,Diagram):
secondEditor=p.editor
assert(secondEditor)
secondEditor.deleteDiagram()
self.smw.undo()
self.smw.redo()
--- NEW FILE: PropertyEditorTester.py ---
from smw.modeler.DialogEditor import *
from smw.smwQtApplication import *
from smw.Project import *
import types
class PEtester(smwQtApplication):
def __init__(self,metamodel):
smwQtApplication.__init__(self)
self.metamodel=metamodel
self.project=Project()
self.project.root=self.metamodel.Model()
self.processEvents()
self.move(0,0)
self.resize(700,500)
def test(self,PEClass,elementsToEdit=[]):
assert(issubclass(PEClass,PropertyEditor))
print "Testing ",PEClass.__name__
self.pe=PEClass(self,self.project)
self.pe.resize(600,400)
self.pe.show()
self.processEvents()
self.pe.focusOn(None)
self.processEvents()
supportedElements=[]
excludes=self.pe.supercedes()
assert(PEClass not in excludes)
for c in self.metamodel.__dict__.values():
if type(c)==types.ClassType and \
issubclass(c,self.metamodel.ModelElement):
e=c()
if self.pe.canEdit(e):
supportedElements.append(c)
print "Supported elements ",supportedElements
if not supportedElements and not elementsToEdit:
print "PropertEditor ",PEClass," cannot edit anything!"
assert(0)
self.project.history.clear()
for c in supportedElements:
e=c()
self.project.history.clear()
self.project.history.beginModifyCmd()
self.pe.focusOn(e)
self.processEvents()
self.pe.apply()
self.project.history.endModifyCmd()
if self.project.history.canUndo():
print "*"*80
print "PropertyEditor ",PEClass,"modifies the model without user interaction."
print "*"*80
#assert(0)
if issubclass(PEClass,ListPropertyEditor):
for c in supportedElements:
e=c()
self.pe.focusOn(e)
self.processEvents()
self.pe.add()
self.pe.add()
self.pe.add()
self.pe.delete([0,1,2])
self.pe.apply()
self.processEvents()
#check if elements really deleted:
assert(not eval("e.%s"%self.pe.getAssociationName()))
for e in elementsToEdit:
assert(self.pe.canEdit(e))
self.pe.focusOn(e)
for i in range(10000):
self.processEvents()
self.pe.apply()
self.processEvents()
--- NEW FILE: __init__.py ---
--- NEW FILE: pycov.py ---
import os
import sys
import getopt
__programname__ = "pycov"
__version__ = "0.1"
__author__ = "Marcus Alanen"
import sys
import types
from profile import Profile
import inspect
import re
import os
import string
import time
import thread
import unittest
__trace_lock__ = None
if __trace_lock__ == None:
__trace_lock__ = thread.allocate_lock()
__debugCT__ = 0
class FileTestCoverage:
def __init__(self, filename, inputfilename = None):
self.filename = filename
if inputfilename:
self.inputfilename = inputfilename
else:
self.inputfilename = filename
self.enabled = 1
self.unused_functions = {}
# map of linenumber to usage count
self.lines_used = {}
lines = self.__getSourceLines__()
if lines == -1:
self.enabled = 0
return
self.max_lines = lines
for i in range(lines+1):
self.lines_used[i] = 0
self.current_function = None
self.current_function_unused = 1
def __fixOldFunc__(self):
if self.current_function and self.current_function_unused:
self.unused_functions[self.current_function] = 1
#print "Function %s is unused!" % self.current_function
self.current_function = None
self.current_function_unused = 1
def __getSource__(self):
"""Returns the source file as an array of lines."""
if not self.enabled:
return
global __debugCT__
if __debugCT__:
print "Getting source for", self.inputfilename
try:
lines = [None] # dummy line is line number 0
f = file(self.inputfilename)
# There must be a faster way, python has already loaded
# the file...
while 1:
t = f.readline()
if not t:
break
lines.append(t)
f.close()
return lines
except:
print "*** Could not load", self.inputfilename
for i in sys.exc_info():
print i
def __getSourceLines__(self):
"""Counts the lines in the source file."""
try:
f = file(self.inputfilename)
lines = 0
# There must be a faster way, python has already loaded
# the file...
while f.readline():
lines += 1
f.close()
global __debugCT__
if __debugCT__:
print self.inputfilename, "has", lines, "lines."
return lines
except:
print "*** Could not load", self.inputfilename
for i in sys.exc_info():
print i
return -1
def cover(self, linenumber, bump = 1):
"""Cover this line of the source file. Basically, just
knock its linenumber reference up one step."""
if not self.enabled:
return
assert(self.lines_used.has_key(linenumber))
self.lines_used[linenumber] += bump
def check(self):
"""Checks the source file line-by-line. This is to
find empty lines and comment lines."""
if not self.enabled:
return
lines = self.__getSource__()
#
#
#
#
current_class = ""
current_class_column = 0
# This keeps empty lines after used regions as used,
# but empty lines after unused regions as unused...
# => Looks neater?
used = 1
# If previous_line_continues
previous_line_continues = 0
for i in range(1, self.max_lines+1):
theline = lines[i]
if self.lines_used[i] > 0:
used = 1
##
## SYNTAX CHECK
## Find classes, functions, exceptions...
##
# MATCH CLASS
m = re.match("^\s*(class)\s+([\w]+)", theline)
if m:
current_class = m.group(2) # BUG nested classes?
current_class_column = m.start(1)
###print "Found class", current_class
continue
# MATCH FUNCTION
m = re.match("^\s*(def)\s+([\w]+)", theline)
if m:
self.__fixOldFunc__()
output = ""
if not current_class or m.start(1) <= current_class_column:
current_class = ""
output += "Nonclass function "
curfunc = m.group(2) # BUG nested functions?
if current_class:
self.current_function = current_class + "." + curfunc
else:
self.current_function = curfunc
if current_class:
output += current_class + "::"
output += curfunc
if self.lines_used[i] == 0:
output += " (unused)"
###################print output
continue
##
## Do we continue from the previous line
##
if previous_line_continues and self.lines_used[i] == 0:
self.lines_used[i] = previous_line_continues
##
## Decide if this line continues on the next line
##
if re.search("[\\\[\{\(,]\s*$", theline):
previous_line_continues = self.lines_used[i]
else:
previous_line_continues = 0
# Skip used lines
if self.lines_used[i] > 0:
self.current_function_unused = 0
continue
##
## EMPTY LINE CHECK
##
# Empty lines and lines with comments are "used"
if used and re.match("^\s*#", theline):
self.lines_used[i] = -1
elif used and re.match("^\s*$", theline):
self.lines_used[i] = -1
else:
# The ending '}' of hashes
if i and self.lines_used[i-1] != 0 and re.match("^\s*}\s*$", theline):
self.lines_used[i] = self.lines_used[i-1]
else:
used = 0
def dump(self, outputstream):
"""Dumps according to usage, empty lines (N/A) and unused lines."""
if not self.enabled:
return
#outputstream.write("Test coverage for file %s." % self.filename)
for line in range(1, self.max_lines+1):
outputstream.write("%s:%d:%d%s" % (self.filename,line, self.lines_used[line], os.linesep))
def dumpHTML(self, outputdir):
"""Dumps HTML according to usage."""
if not self.enabled:
return
f = self.filename
if f[0] == "/":
f = f[1:]
try:
outpath = outputdir
for i in string.split(f, "/")[:-1]:
outpath = outpath + os.sep + i
try:
os.stat(outpath)
except:
os.mkdir(outpath)
output = file(outpath + os.sep + string.split(f, "/")[-1] + ".html", "wb")
output.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n")
output.write("<html><head>\n")
output.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=iso-8859-15\">\n")
output.write("<title>")
output.write("</title>")
output.write("</head>\n")
output.write("<body>\n")
output.write("<pre>")
lines = self.__getSource__()
for i in range(1, self.max_lines+1):
usecount = self.lines_used[i]
#
# Output usage count
if usecount > 0:
output.write("%8d " % usecount)
else:
output.write(" ")
if usecount > 0:
output.write("<font color=\"#009900\">")
elif usecount == 0:
output.write("<font color=\"#ff0000\">")
elif usecount < 0:
output.write("<font color=\"#999900\">")
l = lines[i]
l = string.replace(l, "\n", "")
l = string.replace(l, "&", "&")
l = string.replace(l, "<", "<")
l = string.replace(l, ">", ">")
output.write(l)
output.write("</font>\n")
except:
for i in sys.exc_info():
print i
output.write("</body></html>\n")
def summary(self, fd, htmlPrefix):
if not self.enabled:
return
thefuncs = self.unused_functions.keys()
if len(thefuncs) == 0:
return
thefuncs.sort()
fd.write("<h3>Unused functions in <a href=\"" + htmlPrefix + self.filename[1:] + ".html\">" + self.filename + "</a>" + "</h3>\n")
for i in thefuncs:
# The [1:] strips the leading '/' char from the filename
# bad for urls...
fd.write(i + "<br />\n")
class TestCoverage:
def __init__(self):
self.files = {}
def add(self, filename, inputfilename, linenumber, bump = 1):
"""Cover a linenumber from a file. The appropriate
FileTestCoverage object will be added if necessary."""
if not self.files.has_key(filename):
self.files[filename] = FileTestCoverage(filename, inputfilename)
self.files[filename].cover(linenumber, bump)
def end(self):
for f in self.files.keys():
self.files[f].check()
def dump(self, outputstream):
for f in self.files.keys():
self.files[f].dump(outputstream)
def dumpHTML(self, outputdir, umask = 022):
"""Dumps HTML files into current directory."""
oldumask = os.umask(umask)
for f in self.files.keys():
self.files[f].dumpHTML(outputdir)
os.umask(oldumask)
def __mycmp__(self, x, y):
if self.files[x].filename < self.files[y].filename:
return -1
if self.files[x].filename > self.files[y].filename:
return 1
return 0
def summary(self, fd, htmlPrefix):
files = self.files.keys()
files.sort(self.__mycmp__)
for f in files:
self.files[f].summary(fd, htmlPrefix)
class CoverageProfile:
def __init__(self):
self.testCoverage = TestCoverage()
# Because python mangles the filenames in frame.f_code.co_filename
# Argh!
self.real_filename_cache = {}
# Regular expressions with which we adjust filenames
self.regexps = []
def do(self, sourcefile):
# BUG
# Make the program believe it is really the master Python
# program.
# DON'T use the __name__: __main__ trick, it doesn't buy you
# anything with
l = {"trace_function": self.trace }
sys.settrace(self.trace)
print sourcefile, os.getcwd()
try:
execfile(sourcefile, l, l)
run = None
for x in l:
try:
if x and issubclass(l[x], unittest.TestCase):
print "Running tests with unittest..."
run = os.getcwd()
# BUG BUG BUG
# Horrible hack
run = re.sub(".*/smw/", "smw/", run)
run += "/" + sourcefile
run = re.sub(".py$", "", run)
run = re.sub("/", ".", run)
break
except:
pass
if run:
print "Running", run, "instead"
unittest.main(run)
except:
# We catch *everything*, even sys.exit()
for i in sys.exc_info():
print "exc", i
import traceback
traceback.print_exc(file=sys.stderr)
sys.settrace(None)
def addFromFile(self, fromfilename):
f = file(fromfilename)
while 1:
line = f.readline()
if not line:
break
(filename, linenumber, refcount) = line.split(":")
inputfilename = filename
# We must remember to mangle the filename when joining
for (re_from, re_to) in self.regexps:
filename = re.sub(re_from, re_to, filename)
self.testCoverage.add(filename, inputfilename, int(linenumber), int(refcount))
def cleanUp(self):
# We are done, give the test coverage some breathing room...
self.testCoverage.end()
def produceHTML(self, outputdir):
try:
os.mkdir(outputdir)
except:
pass # It might exist already
self.testCoverage.dumpHTML(outputdir)
def end(self, fd):
if not fd:
fd = sys.stdout
# Dump statistics
self.testCoverage.dump(fd)
def createSummary(self, fd, htmlPrefix):
if not fd:
fd = sys.stdout
fd.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n")
fd.write("<html><head>\n")
fd.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=iso-8859-15\">\n")
fd.write("<title>Summary for test coverages</title>")
fd.write("</head>\n")
fd.write("<body>\n")
fd.write("<p><strong>User</strong>: %s</p>\n" % (os.environ.get("USER", "<unknown>")))
# bah, %z doesn't seem to work on this python installation... Use %Z
fd.write("<p><strong>Date</strong>: " + time.strftime("%a, %d %b %Y %H:%M:%S %Z", time.localtime()) + "</p>\n")
fd.write("<p>Go to the <a href=\".\">files</a>.</p>\n")
self.testCoverage.summary(fd, htmlPrefix)
fd.write("</body></html>\n")
def addRegexps(self, regexplist):
self.regexps.extend(regexplist)
def trace(self, frame, event, arg):
if event == "return":
return
# This is some magic at the start of the program
filename = frame.f_code.co_filename
if filename == "<string>":
return self.trace
global __trace_lock__
__trace_lock__.acquire()
try:
if self.real_filename_cache.has_key(filename):
filename = self.real_filename_cache[filename]
else:
oldfilename = filename
# Some weirdo python again...
if filename[0] != "/":
filename = os.getcwd() + os.sep + filename
else:
# Fix filenames like:
# /var/tmp/python-2.2.2-root/usr/lib/python2.2/xmlrpclib.py
for (re_from, re_to) in self.regexps:
filename = re.sub(re_from, re_to, filename)
#filename = re.sub("/var/tmp/[^/]*/", "/", filename)
# Add to cache
self.real_filename_cache[oldfilename] = filename
#print filename, frame.f_lineno
self.testCoverage.add(filename, filename, frame.f_lineno)
except:
__trace_lock__.release()
raise
__trace_lock__.release()
return self.trace
def usage():
print __programname__ + " -- Python program coverage tester, version " + __version__
print ""
print "This program is designed to run a series of unittests, one at a time."
print "It gathers information of what Python program lines are executed,"
print "finally producing a summary of executed lines. Currently, output"
print "is available in HTML. A general summary of various data can also"
print "be requested."
print ""
print "Usage: pycov [--help|--version]"
print "Usage: pycov [--coverage=file] [--type=(html|txt)] [--outputdir=dir]"
print " [--summary=file] program arg1..."
print "Usage: pycov --join [--type=(html|txt)] [--outputdir=dir]"
print " [--summary=file] coverage..."
print ""
print "The --join option joins coverage reports."
print "The --coverage option tells into which file the resulting coverage"
print "should be placed."
print "The --summary option produces a (HTML) summary of tests. (N/A)"
print "The --outputdir tells into which dir to create the coverage of each file."
print "Usually, you want to use this option last with --join, after all tests"
print "have been run."
print "The --type option specifies output type. (N/A)."
print ""
longOpts = ["help", "join", "coverage=", "ignore=", "replace=", "type=", "outputdir=", "summary=", "version"]
try:
opts,applicationArgs = getopt.getopt(sys.argv[1:], "", longOpts)
except getopt.GetoptError, e:
raise e
join = 0
coverage=None
type=None
outputdir=None
summary=None
replacethese = []
ignorethese = []
for o,a in opts:
if o == "--help":
usage()
sys.exit(0)
if o == "--version":
print __programname__ + " " + __version__
sys.exit(0)
if o == "--join" and not join:
join = 1
continue
if o == "--replace":
try:
splitchar = a[0]
(_, re_from, re_to, _) = a.split(splitchar)
except:
sys.stderr.write("pycov: Error while parsing regular expression '%s'%s" % (a, os.linesep))
sys.exit(1)
replacethese.append((re_from, re_to))
continue
if o == "--coverage" and not coverage:
coverage=a
continue
if o == "--ignore":
ignorethese.append(a)
continue
if o == "--type":
if a != "txt" and a != "html":
sys.stderr.write("pycov: option " + a + " to --type not supported." + os.linesep)
sys.exit(1)
else:
sys.stderr.write("pycov: warning: ignoring option to --type, producing HTML" + os.linesep)
continue
if o == "--outputdir" and not outputdir:
outputdir = a
continue
if o == "--summary" and not summary:
summary = a
continue
# Default fail
sys.stderr.write("Unknown option or same option given several times." + os.linesep)
sys.exit(1)
c = CoverageProfile()
c.addRegexps(replacethese)
sys.argv = applicationArgs
summaryfd = None
if summary:
# Open now so no chdirs can interfere
summaryfd = file(summary, "wb")
coveragefd = None
if coverage:
coveragefd = file(coverage, "wb")
# Join previous test coverages
if join:
for i in applicationArgs:
c.addFromFile(i)
# Run a test program instead.
#
# This is perhaps not the best way,
# probably depends on how python and PYTHONPATH
# is configured. Argh!^2
else:
if len(sys.argv) == 0:
usage()
sys.exit(1)
cmd = sys.argv[0]
splitted = cmd.split(os.sep)
cmd = splitted[-1]
path = splitted[:-1]
for i in path:
if i == "":
i = "/"
try:
os.chdir(i)
except:
print "Couldn't chdir to", i
sys.exit(255)
#sys.stderr.write("Executing test %s%s" % (cmd, os.linesep))
c.do(cmd)
if coverage:
c.end(coveragefd)
# Cleanup after writing the coverage
c.cleanUp()
if outputdir:
c.produceHTML(outputdir)
if summary:
htmlPrefix = ""
if outputdir:
html_prefix = outputdir
c.createSummary(summaryfd, htmlPrefix)
--- NEW FILE: unittester.py ---
(This appears to be a binary file; contents omitted.)
|
|
From: <de...@us...> - 2004-01-07 02:00:51
|
Update of /cvsroot/pymerase/smw/smw/scw/modeler/unittest
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/scw/modeler/unittest
Added Files:
__init__.py testSCWEditorBasics.py testUMLSCWCorePE.py
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: __init__.py ---
--- NEW FILE: testSCWEditorBasics.py ---
from smw.testdriver.DiagramEditorTester import *
import unittest
class testEditor(unittest.TestCase):
def setUp(self):
self.t=DiagramEditorTester(profile="UML14SFI")
def testEditors(self):
# test adding the elements
valid=["addClassTool","addInterfaceTool","addPackageTool","addLayerTool"]
for x in valid:
self.addPlaceAction(self.t.getMainEditor(),x,50,50,150,150)
# test adding an element above previous element
valid=["addPackageTool"]
invalid=["addClassTool","addInterfaceTool","addLayerTool"]
for x in valid:
self.addPlaceAction(self.t.getMainEditor(),x,50,50,55,55)
for x in invalid:
self.addPlaceAction(self.t.getMainEditor(),x,50,50,55,55,succeed=0)
# test dependency
valid=["addClassTool","addInterfaceTool","addPackageTool","addLayerTool"]
for x in valid:
self.t.testActionCombo(self.t.getMainEditor(),x,"addClassTool","addDependencyTool",selfLink=0)
# test that dependency cannot be created between two layers
self.failingLinkAction(self.t.getMainEditor(),"addLayerTool","addLayerTool","addDependencyTool")
# test Generalization
valid=["addClassTool","addInterfaceTool"]
for x in valid:
self.t.testActionCombo(self.t.getMainEditor(),x,"addClassTool","addGeneralizationTool",selfLink=0)
# test for invalid cases
invalid=["addPackageTool","addLayerTool"]
for x in invalid:
for y in valid:
self.failingLinkAction(self.t.getMainEditor(),x,y,"addGeneralizationTool")
for y in invalid:
self.failingLinkAction(self.t.getMainEditor(),x,y,"addGeneralizationTool")
# test association
valid=["addClassTool","addInterfaceTool"]
for x in valid:
self.t.testActionCombo(self.t.getMainEditor(),"addClassTool",x,"addAssociationTool")
# test for invalid cases
invalid=["addPackageTool","addLayerTool"]
for x in invalid:
for y in valid:
self.failingLinkAction(self.t.getMainEditor(),x,y,"addAssociationTool")
for y in invalid:
self.failingLinkAction(self.t.getMainEditor(),x,y,"addAssociationTool")
def failingLinkAction(self,de,first,second,link):
de.expossed()
h=de.mainWindow.actions.getHandler(first,de)
if not h:
raise "Unknown action",first
h()
firstE=de.currentGesture.onAdd((50,50))
firstP=self.t.presentationsOfElement(firstE,de)[0]
h=de.mainWindow.actions.getHandler(second,de)
if not h:
raise "Unknown action",second
h()
secondE=de.currentGesture.onAdd((150,150))
secondP=self.t.presentationsOfElement(secondE,de)[0]
h=de.mainWindow.actions.getHandler(link,de)
h()
linkE=de.currentGesture.onLink(firstP,secondP,[[50,50],[150,150]])
assert(not linkE)
de.selectAll()
de.deleteSelection()
def addPlaceAction(self,de,a,x1,y1,x2,y2,succeed=1):
print de
h=de.mainWindow.actions.getHandler(a,de)
h()
if not isinstance(de.currentGesture,smw.modeler.Gestures.AddElementG):
raise "action "+str(a)+" does not activate AddElementG"
# create an element
e=de.currentGesture.onAdd((x1,y1))
if not isinstance(e,MetaMM.Element):
raise str(de.currentGesture.onAdd)+" does not return a model element"
if e.presentation.size()==0:
raise "Element "+str(e)+" does not have presentations!"
name1=e.name
e2=de.currentGesture.onAdd((x2,y2))
if succeed:
name2=e2.name
if name1==name2:
raise "Each element should have a different name. Action ",a
pe=self.t.presentationsOfElement(e,de)
if not pe:
raise "Element "+str(e)+" does not a have presentation in the diagram!"
else:
assert(not e2)
self.t.testMove(e,de)
self.t.testHideAndDrop(e,de)
self.t.testDelete(e,de)
de.selectAll()
de.deleteSelection()
if __name__ == '__main__':
unittest.main()
--- NEW FILE: testUMLSCWCorePE.py ---
from smw.scw.modeler.UMLSCWCorePE import *
from smw.metamodel import UML14
from smw.modeler import DialogEditor
from smw.scw.modeler.UMLSCWAssociationEditor import *
from smw.scw.modeler.UMLSCWOperationEditor import *
from smw.scw.modeler.UMLSCWAttributeEditor import *
from smw.scw.modeler.UMLSCWModelElementPE import *
from smw.smwQtApplication import *
from smw.metamodel import TransactionManager
from smw.modeler.profiles.scwProfile import *
from smw import Project
import unittest
class testPropertyEditors(unittest.TestCase):
def testEditors(self):
a=testUMLSCWCorePE()
class testUMLSCWCorePE(smwQtApplication):
def __init__(self):
smwQtApplication.__init__(self)
self.metamodel=metamodel
#self.project=Proj()
#self.project=Project()
#self.project.theSFIManager=SfiManager(TransactionManager.theTM)
temp=['smw.scw.modeler.UMLSCWCore',
'smw.modeler.UMLADEditor',
'smw.modeler.UML.UMLSCEDitor',
'smw.modeler.UML.UMLCollaborationEditor',
'smw.modeler.UML.UMLUCEEditor',
'smw.modeler.UML.UMLSDEditor']
self.project=Project.Project("ProjectName",SCWProfile("te",self.metamodel,temp))
self.sMan=self.project.getProfile().theSFIManager
#self.project.root=self.metamodel.Model()
self.processEvents()
self.move(0,0)
self.resize(700,500)
self.sMan.focusOnElement(self.sMan.currentProject())
A=self.sMan.newClass()
self.test(UMLSCWClassPE,[Class],[A])
self.test(UMLSCWApplicationPE,[Class],[A])
self.test(UMLSCWTestDocumentationPE,[Class],[A])
TC=self.sMan.layerManager().getTestClient(A)
self.test(UMLSCWClassDocumentationPE,[Class],[TC])
#self.test(UMLSCWParameterPE,[Parameter],[])
self.sMan.focusOnElement(A)
OP=self.sMan.newOperation()
self.test(UMLSCWOperationPE,[Operation],[OP])
self.sMan.focusOnElement(A)
AT=self.sMan.newAttribute()
self.test(UMLSCWAttributePE,[Attribute],[AT])
self.sMan.focusOnElement(self.sMan.currentProject())
B=self.sMan.newClass()
AS=self.sMan.newAssociation(A,B)
self.test(UMLSCWAssociationPE,[Association],[AS])
self.sMan.focusOnElement(self.sMan.currentProject())
PA=self.sMan.newPackage()
IN=self.sMan.newInterface()
LA=self.sMan.newLayer()
self.sMan.focusOnElement(LA)
CLA=self.sMan.newClass()
DE=self.sMan.newDependency(A,B)
GE=self.sMan.newGeneralization(A,B)
self.test(UMLSCWModelElementPE,[Interface,Package,"Layer",Dependency,Generalization],[IN,PA,LA,DE,GE])
self.test(UMLSCWLayerPE,["Layer"],[LA])
self.test(UMLSCWRunPackageTestsPE,[Package],[PA])
self.test(UMLSCWCorrectnessPE,[Class,Package,"Layer"],[A,PA,LA])
self.test(UMLSCWAttributeListPE,[Class],[A])
self.test(UMLSCWClass1PE,[Class],[CLA])
self.test(UMLSCWOperationListPE,[Interface,Class],[IN,A])
self.test(UMLSCWParameterListPE,[Operation],[OP])
self.pe.focusOn(None)
self.processEvents()
def test(self,PEClass,supported,elementsToEdit):
assert(issubclass(PEClass,PropertyEditor))
print "Testing ",PEClass.__name__
self.pe=PEClass(self,self.project)
self.pe.resize(600,400)
self.pe.show()
for c in supported:
e=self.makeElement(c)
self.project.history.clear()
assert(e)
self.pe.focusOn(e)
self.processEvents()
self.pe.apply()
if self.project.history.canUndo():
print "PropertyEditor ",PEClass,"modifies the model without user interaction. BAD!"
assert(0)
if issubclass(PEClass,ListPropertyEditor):
for x in supported:
e=self.makeElement(x)
assert(e)
self.pe.focusOn(e)
self.processEvents()
self.pe.add()
self.pe.add()
self.pe.add()
self.pe.add()
self.pe.add()
self.pe.delete([0,1,2,3,4])
for x in elementsToEdit:
assert(self.pe.canEdit(x))
self.pe.focusOn(e)
for i in range(1000):
self.processEvents()
self.pe.apply()
self.processEvents()
def makeElement(self,x):
self.sMan.focusOnElement(self.sMan.currentProject())
if x==self.metamodel.Class:
a= self.sMan.newClass()
return a
elif x==self.metamodel.Interface:
a=self.sMan.newInterface()
return a
elif x==self.metamodel.Package:
a=self.sMan.newPackage()
return a
elif x==self.metamodel.Attribute:
self.sMan.newClass()
return self.sMan.newAttribute()
elif x==self.metamodel.Operation:
self.sMan.newClass()
return self.sMan.newOperation()
elif x==self.metamodel.Association:
a= self.sMan.newClass()
self.sMan.focusOnElement(self.sMan.currentProject())
b= self.sMan.newClass()
as=self.sMan.newAssociation(a,b)
return as
elif x=="Layer":
a=self.sMan.newLayer()
return a
elif x==self.metamodel.Dependency:
a= self.sMan.newClass()
self.sMan.focusOnElement(self.sMan.currentProject())
b= self.sMan.newClass()
as=self.sMan.newDependency(a,b)
return as
elif x==self.metamodel.Generalization:
a= self.sMan.newClass()
self.sMan.focusOnElement(self.sMan.currentProject())
b= self.sMan.newClass()
as=self.sMan.newGeneralization(a,b)
return as
else:
return x()
if __name__ == '__main__':
unittest.main()
|
|
From: <de...@us...> - 2004-01-07 01:48:33
|
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()
|
|
From: <de...@us...> - 2004-01-07 01:48:33
|
Update of /cvsroot/pymerase/smw/smw/scw/Element
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/scw/Element
Added Files:
LayerManager.py SfiManager.py __init__.py python.iml
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: LayerManager.py ---
#!/usr/bin/env python2
__layer__ = 'Element'
import unittest
from smw.metamodel import UML14 as metamodel
from smw.transform.uml2py.uml2py import isNameValid
import string
def mkTestCaseName(name):
"""returns name for test case of class 'name'"""
tName = string.capitalize(name[0]) + name[1:]
tName = unittest.TestLoader.testMethodPrefix + tName
return tName
mkTestMethodName = mkTestCaseName
def mkTestDependencyName(name):
""" Returns a name for the dependency between the class and its testclass """
[...1271 lines suppressed...]
"""
Create a unique name for element and returns it
"""
if not isinstance(name,str):
return None
if not(isinstance(element,metamodel.ModelElement)):
return None
eles=self.returnElements(element)
names=[]
for k in eles:
names.append(k.name)
x=1
while(names.count(name+str(x))>0):
x=x+1
return name+str(x)
--- NEW FILE: SfiManager.py ---
#!/usr/bin/env python2
"""
This layer can add different elements to the model. Also deleting and renaming
elements is added here
"""
__layer__ = 'Element'
from smw.metamodel import UML14 as metamodel
from smw.transform.uml2py.uml2py import isNameValid
from LayerManager import LayerManager
from smw.scw.Project.SfiManager import SfiManager as ProjectSfiManager
from LayerManager import mkTestCaseName, mkTestMethodName,mkTestDependencyName
def mkUnittestDependencyName(pname):
return pname+"UTDep"
class SfiManager(ProjectSfiManager):
def __init__(self):
"""
Constructor for a new SfiManager.
"""
ProjectSfiManager.__init__(self)
def setUp(self):
ProjectSfiManager.setUp(self)
self._layerManager=LayerManager()
self._currentElements={}
self._unittestPackage={}
self._testCaseClass={}
def unittestPackage(self):
""" Returns the unitest package """
return self._unittestPackage
def testCaseClass(self):
""" Returns the testcaseclass dictonary """
return self._testCaseClass
def layerManager(self):
""" returns an instance of the LayerManager class """
return self._layerManager
def newProject(self, projectName = None):
"""
Calls the newProject method in Project layer. Initializes the created project to the currentElements dictionary.
"""
project=ProjectSfiManager.newProject(self,projectName)
if project==None:
return None
for x in project.ownedElement:
if(x.name=="python2_2"):
for q in x.ownedElement:
if(q.name=="unittest"):
self._unittestPackage[project]=q
for y in q.ownedElement:
if(y.name=="TestCase"):
self._testCaseClass[project]=y
break
self._currentElements[project.name]=self.currentProject()
d=self.addUnittestDependency(project)
assert(d)
return project
def deleteProject(self, arg):
"""
Calls the method in Project layer. Deletes the project from the currentElements dictionary.
"""
deletedProject=ProjectSfiManager.deleteProject(self,arg)
if deletedProject==None:
return None
# delete the dependency to unittest package
# NÄITÄ EI TARVITISI TEHDÄ NYT KUN KÄYTETÄÄN KAIKLLA PROJEKTEILLA OMAA PYTHON PAKKAUSTA
for d in deletedProject.clientDependency:
for c in d.supplier:
if(c==self._unittestPackage[deletedProject]):
self.deleteElement2(d)
for e in self._layerManager.returnElements(deletedProject):
if isinstance(e,metamodel.Class) and self._layerManager.getTestSupplier(e):
for g in e.generalization:
p=g.parent
if p==self._testCaseClass[deletedProject]:
self.deleteElement2(g)
del self._testCaseClass[deletedProject]
del self._unittestPackage[deletedProject]
if isinstance(arg,str):
del self._currentElements[arg]
elif isinstance(arg,metamodel.Model):
del self._currentElements[arg.name]
return deletedProject
def renameProject(self, oldName, newName):
"""
Calls the method in Project layer. Changes the key in the currentElements dictionary.
"""
eles=self._layerManager.returnElements(self.currentProject())
pnames=[]
for e in eles:
if e.oclIsKindOf(metamodel.Package) and not e.oclIsKindOf(metamodel.Model):
pnames.append(e.name)
if newName in pnames:
return
rName=ProjectSfiManager.renameProject(self,oldName,newName)
if rName==None:
return None
value=self._currentElements[oldName]
del self._currentElements[oldName]
self._currentElements[newName]=value
return rName
def loadProject(self, fname):
"""
Loads a project.
set the current element correctly.
"""
uModel = ProjectSfiManager.loadProject(self,fname)
if uModel:
self._currentElements[uModel.name]=uModel
for x in range(len(uModel.ownedElement)):
e=uModel.ownedElement[x]
if (e.oclIsKindOf(metamodel.Package) and e.name=="python2_2"):
# Find the loaded packages:
# loadedUTPackage=None
# loadedTestCaseClass=None
for y in e.ownedElement:
if(y.name=="unittest"):
# loadedUTPackage=y
self._unittestPackage[uModel]=y
for z in y.ownedElement:
if(z.name=="TestCase"):
# loadedTestCaseClass=z
self._testCaseClass[uModel]=z
break
packs=[]
classes=[]
lclclc=self._layerManager.returnElements(uModel)
for p in lclclc:
if p.oclIsKindOf(metamodel.Package):
packs.append(p)
for clas in lclclc:
if clas.oclIsKindOf(metamodel.Class):
classes.append(clas)
for c in classes:
# mark the class abstract if all it's operations do not have methods
for f in c.feature:
if f.oclIsKindOf(metamodel.Operation) and not f.method:
c.isAbstract=1
# check if the class is in python package
ns=c.namespace
inpp=None
while not ns==uModel:
if ns.name=='python2_2':
inpp=1
ns=uModel
else:
ns=ns.namespace
if not inpp:
if not self._layerManager.isTestClass(c):
if not self._layerManager.getTestClient(c):
tc=metamodel.Class()
tc.name=mkTestCaseName(c.name)
tc.namespace=c.namespace
self._layerManager.attachTag(tc,'testcase')
self.newDependency(c,tc,mkTestDependencyName(c.name))
self.newGeneralization(self._testCaseClass[uModel],tc)
# add operations and methods to testClass
# test class is made concrete, even if the real class is not
ops=c.feature.select(lambda x: x.oclIsKindOf(metamodel.Operation))
for o in ops:
to=self._layerManager.newOperation(tc,mkTestMethodName(o.name))
if o.method:
for m in o.method:
self._layerManager.newMethod(tc,mkTestMethodName(o.name),to)
## else:
## self._layerManager.newMethod(tc,mkTestMethodName(o.name),to)
else:
tc.isAbstract=1
for p in packs:
ns=p
inpp=None
while not ns==uModel:
if ns.name=='python2_2':
inpp=1
ns=uModel
else:
ns=ns.namespace
if not inpp:
ud=None
for d in p.clientDependency:
for s in d.supplier:
if s==self.unittestPackage()[uModel]:
ud=d
if not ud:
self.newDependency(self.unittestPackage()[uModel],p,mkUnittestDependencyName(p.name))
self.focusOnElement(uModel)
return uModel
## lElements=self._layerManager.returnElements(uModel)
## for y in lElements:
## # Create new unittest dependecies (and remove old ones):
## if (y.oclIsKindOf(metamodel.Package)):
## classes=y.ownedElement.select(lambda z: z.oclIsKindOf(metamodel.Class))
## if (classes):
## deps=y.clientDependency.select(lambda z: z.supplier.select(lambda w: w==loadedUTPackage))
## if (deps and len(deps)==1):
## d=deps[0]
## s=d.supplier[0]
## c=d.client[0]
## self._layerManager.deleteElement2(d)
## self.newDependency(s,self._unittestPackage, mkUnittestDependencyName(c))
## # Create new generalizations for test classes (and remove the old ones):
## if (y.oclIsKindOf(metamodel.Class) and not self._layerManager.getTestClient(y)):
## gens=y.generalization.select(lambda z: z.parent==loadedTestCaseClass)
## if gens and len(gens)==1:
## g=gens[0]
## p=g.parent
## c=g.child
## self._layerManager.deleteElement2(g)
## self.newGeneralization(p,self._testCaseClass)
## self.deleteElement2(uModel.ownedElement[x])
## break
## uModel.ownedElement.append(self.pythonPackage())
def currentElement(self,proj=None):
"""
Returns the current element of the project given as parameter
-if no parameter is given returns the current element of the current project
"""
if(proj==None):
if(len(self.projects())<1):
return None
else:
return self._currentElements[self.currentProject().name]
if(isinstance(proj,metamodel.Model)):
for x in self.projects().keys():
if(x==proj.name):
return self._currentElements[proj.name]
return self.currentElement()
elif(isinstance(proj,str)):
for x in self.projects().keys():
if(x==proj):
return self._currentElements[proj]
return self.currentElement()
else:
return self.currentElement()
def focusOnElement(self,object):
"""
Focuses on the given element or project and returns it if
-given parameter is of valid type
-given parameter exists in manager
else returns the previous current element
"""
owner=object
if(isinstance(object,metamodel.Method) or isinstance(object,metamodel.Attribute) or isinstance(object,metamodel.Operation)):
owner1=object.owner
if(owner1==None): #the object isn't attached to any class or interface
owner=owner.namespace
if(owner==None):#the object isn't attached to any project
return self.currentElement()
else: #owner1!=None
owner=owner1
if(isinstance(owner,metamodel.Class) or isinstance(owner,metamodel.Interface) or isinstance(owner,metamodel.Generalization) or isinstance(owner,metamodel.Association) or isinstance(owner,metamodel.Dependency) or isinstance(owner,metamodel.Package) or isinstance(owner,metamodel.Model)): #tests if the object is a class diagram element
#gets the project in which the owner belongs
while(not isinstance(owner,metamodel.Model)):
owner=owner.namespace
if(owner==None):
return self.currentElement() ##
#checks wether the project belongs to the manager
if(self.projects().has_key(owner.name)):
self.focusOnProject(self.projects()[owner.name])
self._currentElements[owner.name]=object
return self.currentElement()
#else returns the previous current element
else:
return self.currentElement() ##
#else (if parameter type invalid) returns the previous current element
else:
return self.currentElement() ##
def addUnittestDependency(self, package):
"""
Adds 'unittest' depency to given package (or model)
- not created if it allready exists or parameter if not of correct type.
Does not change the focus
"""
if not self.currentProject():
return
if not isinstance(package,metamodel.Package):
return
if isinstance(package,metamodel.Model) and not self._projects.has_key(package.name):
return
dep=None
f=0
for d in package.clientDependency:
for s in d.supplier:
if s==self._unittestPackage[self.currentProject()]:
f=1
if not f:
name=mkUnittestDependencyName(package.name)
name=self.createUniqueElementName(self.currentProject(),name)
dep=self._layerManager.newDependency(self._unittestPackage[self.currentProject()],package,name)
return dep
def newClass(self, newName=None):# - adding to current element, if it is a project or package
if not newName:
newName=self.createUniqueElementName(self.currentElement(),"class")
createdClass=self._layerManager.newClass(self.currentElement(),newName)
if createdClass:
testClass=self._layerManager.getTestClient(createdClass)
gen=self.newGeneralization(self._testCaseClass[self.currentProject()],testClass)
if not gen:
raise 'Could not create the test generalization'
self.focusOnElement(createdClass)
return createdClass
def newInterface(self,newName=None):#- adding to current element, if it is a project or package
if not newName:
newName=self.createUniqueElementName(self.currentElement(),"interface")
createdInterface=self._layerManager.newInterface(self.currentElement(),newName)
self.focusOnElement(createdInterface)
return createdInterface
def newGeneralization(self,parent,child,newName=None):#tested, adding to closest common owner, class or interface
if not newName:
newName=self.createUniqueElementName(self.currentElement(),"generalization")
createdGeneralization=self._layerManager.newGeneralization(parent,child,newName)
self.focusOnElement(createdGeneralization)
return createdGeneralization
def newAssociation(self,end1,end2,newName=None):# - adding to the closest common namespace,project or package.
if not newName:
newName=self.createUniqueElementName(self.currentElement(),"association")
createdAssociation=self._layerManager.newAssociation(end1,end2,newName)
self.focusOnElement(createdAssociation)
return createdAssociation
def newDependency(self,supplier,client,newName=None):# - adding to closest namespace, project or package
if not newName:
newName=self.createUniqueElementName(self.currentElement(),"dependency")
createdDependency=self._layerManager.newDependency(supplier,client,newName)
self.focusOnElement(createdDependency)
return createdDependency
def newPackage(self,newName=None):# - adding to current element, if it is project or package
if newName==self.currentProject().name:
return
if not newName:
newName=self.createUniqueElementName(self.currentElement(),"package")
createdPackage=self._layerManager.newPackage(self.currentElement(),newName)
self.focusOnElement(createdPackage)
self.addUnittestDependency(createdPackage)
return createdPackage
def newMethod(self,newName=None, specification=None):# tested adding to currentElement and to the testClass
if not newName:
newName=self.createUniqueElementName(self.currentElement(),"method")
createdMethod=self._layerManager.newMethod(self.currentElement(),newName,specification)
self.focusOnElement(createdMethod)
return createdMethod
def newOperation(self,newName=None): # tested
if not newName:
newName=self.createUniqueElementName(self.currentElement(),"operation")
createdOperation=self._layerManager.newOperation(self.currentElement(),newName)
self.focusOnElement(createdOperation)
return createdOperation
def newAttribute(self,newName=None):#tested-working - adding to currentElement
if not newName:
newName=self.createUniqueElementName(self.currentElement(),"attribute")
createdAttribute=self._layerManager.newAttribute(self.currentElement(),newName)
self.focusOnElement(createdAttribute)
return createdAttribute
## def deleteElement1(self,element=None): #leaves the relationships hanging
## if (element==None):
## element=self.currentElement()
## if not isinstance(element,metamodel.ModelElement):
## return None
## if(self._layerManager.returnElements(element).count(element)>0):
## if(isinstance(element,metamodel.Attribute) or isinstance(element,metamodel.Method) or isinstance(element,metamodel.Operation)):
## if(element.namespace!=None):
## self.focusOnElement(element.namespace)
## elif(element.owner!=None):
## self.focusOnElement(element.owner)
## # elif(isinstance(element,metamodel.Method)):
## # self.focusOnElement(element.owner)
## else:
## self.focusOnElement(element.namespace)
## deletedElement=self._layerManager.deleteElement1(element)
## return deletedElement
def deleteElement2(self,element=None): #deletes the relationships too
""" Deletes an element and all its relationships """
if (element==None):
element=self.currentElement()
if not isinstance(element,metamodel.ModelElement):
return None
if(self._layerManager.returnElements(element).count(element)>0):
if(isinstance(element,metamodel.Attribute) or isinstance(element,metamodel.Method) or isinstance(element,metamodel.Operation)):
if(element.namespace!=None):
self.focusOnElement(element.namespace)
elif(element.owner!=None):
self.focusOnElement(element.owner)
#elif(isinstance(element,metamodel.Method)):
# self.focusOnElement(element.owner)
else:
self.focusOnElement(element.namespace)
removedependency=0
p=None
deletedElement=self._layerManager.deleteElement2(element)
return deletedElement
def renameElement(self, element, newName):#tested-working
"""
Renames the element to 'newName'
and returns the new name of the element.
Returns none if either one of the parameters is invalid.
"""
if isinstance(element,metamodel.Package):
if newName==self.currentProject().name:
return
ns=element
if isinstance(element,metamodel.Feature) and element.owner:
ns=element.owner
while not ns==self.currentProject():
if ns==self.pythonPackage():
return
ns=ns.namespace
changedName=self._layerManager.renameElement(element,newName)
return changedName
def createUniqueElementName(self,element,defName=None):
"""
Create a unique name for element and returns it
"""
if not defName:
defName="element"
if not isinstance(defName,str):
return None
if not(isinstance(element,metamodel.ModelElement)):
return None
return self.layerManager().createUniqueElementName(element,defName)
--- NEW FILE: __init__.py ---
from SfiManager import *
from LayerManager import *
--- NEW FILE: python.iml ---
(ismw.metamodel.UML14
Model
p1
(dp2
S'isAbstract'
p3
I0
sS'isSpecification'
p4
I0
sS'__uniqueID__'
p5
S'ib351d2ec95de35465f82789cf7689fa7'
p6
sS'isRoot'
p7
I0
sS'visibility'
p8
[...227897 lines suppressed...]
p49406
sg54
S''
sbsg4
I0
sg5
S'iaf81dd77ae2741edd072fd3d40fe0e99'
p49407
sg56
I0
sg8
I0
sg10
S'_normpath'
p49408
sg17
g48793
sg58
I0
sbasbsbasbsbasbsb.
|
|
From: <de...@us...> - 2004-01-07 01:48:33
|
Update of /cvsroot/pymerase/smw/smw/scw/Project
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/scw/Project
Added Files:
SfiManager.py __init__.py python.iml
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: SfiManager.py ---
#!/usr/bin/env python2
"""
The Project layer is the fisrt layer in the SCW project. It can create and delete a project.
Rename and load/save projects.
"""
__layer__ = 'Project'
from smw.metamodel import UML14 as metamodel
from smw.transform.uml2py.uml2py import isNameValid
from smw import io
import os.path
import sys
import smw.Configuration
class SfiManager:
# N = 0
def __init__(self):
"""
Constructor for a new SfiManager.
"""
# self.__class__.N += 1
# if self.__class__.N > 1:
# raise 'More than one instance exists.'
# self.setUp()
config=smw.Configuration.Configuration()
ppObj=config.getParameter("install_path")
pp=ppObj.currentValue
if os.path.isfile(pp+"/scw/python.iml"):
#pythonUMLModel=io.loadModel(pp+"/smw/scw/python.iml")
#self._pythonUMLPackage=pythonUMLModel.ownedElement[0]
self.setUp()
else:
print "You must run the 'smw/scw/make' in command first"
sys.exit()
def pythonPackage(self):
"""returns the python package"""
return self._pythonUMLPackage
def projects(self):
"""returns a dictonary containing the project (more use when the editor
supports several projects)"""
return self._projects
def setUp(self):
"""just clears the attributes,used when starting a new project"""
self._projects={}
self._currentProject=None
self._pythonUMLPackage=None
def __del__(self):
print 'instance of %s.SfiManager deleted' % __layer__
def newProject(self, projectName = None):
"""
Adds a new project to the 'projects' -dictionary. The new project is assigned as current project.
Returns the new Project.
"""
if not projectName:
projectName = self.createUniqueName()
if not isinstance(projectName, str):
return
if len(self._projects)!=0:
return
if isNameValid(projectName):
if self._projects.has_key(projectName):
return
self._projects[projectName] = metamodel.Model()
self._projects[projectName].name=projectName
self._currentProject=self._projects[projectName]
config=smw.Configuration.Configuration()
ppObj=config.getParameter("install_path")
pp=ppObj.currentValue
pythonUMLModel=io.loadModel(pp+"/scw/python.iml")
self._pythonUMLPackage=pythonUMLModel.ownedElement[0]
self._pythonUMLPackage.name="python2_2"
# THIS HAS TO BE CHANGED
self._currentProject.ownedElement.append(self._pythonUMLPackage)
return self._projects[projectName]
else:
return
def createUniqueName(self):
"""
Creates a unique name for a project and returns it.
"""
defName = "Project"
x = 1
while self._projects.has_key(defName + str(x)):
x = x + 1
return defName + str(x)
def deleteProject(self, arg):
"""
Deletes the specified project from the dictionary if it exists.
-arg can be either the name of the project or the project itself
Returns the deleted project.
"""
if isinstance(arg,str):
if not self._projects.has_key(arg):
return None
else:
uModel = self._projects[arg]
del self._projects[arg]
elif isinstance(arg,metamodel.Model):
if not self._projects.has_key(arg.name):
return None
else:
uModel=arg
del self._projects[arg.name]
# if needed to delete project (Current) without arguments add it here
else:
return
if len(self._projects.keys())<1:
self._currentProject=None
else:
firstKey=(self._projects.keys())[0]
self.focusOnProject(firstKey)
return uModel
def renameProject(self, oldName, newName):
"""
Renames the project with the name 'oldName' to 'newName'
and returns the new name of the project.
Returns none if either one of the parameters is invalid.
"""
if isNameValid(newName):
if not self._projects.has_key(oldName):
return
elif self._projects.has_key(newName):
return
else:
value=self._projects[oldName]
del self._projects[oldName]
self._projects[newName]=value
self._projects[newName].name=newName
return newName
else:
return
def currentProject(self):
"""
Returns the current project.
"""
return self._currentProject
def focusOnProject(self,project):
"""
Assigns the project given as parameter to current project and
returns the current project if the parameter is an existing project.
"""
if isinstance(project,str):
if self._projects.has_key(project):
self._currentProject=self._projects[project]
# THIS HAS TO BE CHANGED!!!!!!!!!
#self.pythonPackage().namespace=self.currentProject
return self.currentProject()
else:
return
elif isinstance(project,metamodel.Model):
if self._projects.has_key(project.name):
self._currentProject=project
# THIS HAS TO BE CHANGED!!!!!!!!!!!!!!!!!
#self.pythonPackage().namespace=self.currentProject
return self.currentProject()
else:
return
else:
return
def loadProject(self, fname):
"""
Loads the project from the file named 'fname'.
After loading the current element is the project itself.
Returns the loaded project if the loading succeeded
"""
if self.currentProject():
self._projects={}
if not isinstance(fname, str):
return
if not os.path.isfile(fname):
return
uModel = io.loadModel(fname)
# model was loaded and the name does not exist in the dictionary.
if uModel and not self._projects.has_key(uModel.name):
self._projects[uModel.name] = uModel
self._currentProject = uModel
foundPP=0
for x in range(len(uModel.ownedElement)):
e=uModel.ownedElement[x]
if (e.oclIsKindOf(metamodel.Package) and e.name=="python2_2"):
foundPP=1
if not foundPP:
config=smw.Configuration.Configuration()
ppObj=config.getParameter("install_path")
pp=ppObj.currentValue
pythonUMLModel=io.loadModel(pp+"/scw/python.iml")
self._pythonUMLPackage=pythonUMLModel.ownedElement[0]
self._pythonUMLPackage.name="python2_2"
self._currentProject.ownedElement.append(self._pythonUMLPackage)
return uModel
return
def saveProject(self):
"""
saves the currentProject and returns the name.
"""
if not self.currentProject():
return
fname = self.currentProject().name + ".iml"
savedModel=io.saveModel(fname, self.currentProject())
if savedModel:
return self.currentProject().name
else:
print "Saving unsuccesful!"
return
def saveProjectAs(self, fname):
"""
Saves the project with the given name and returns the name.
"""
if not self.currentProject():
return
savedModel=io.saveModel(fname, self.currentProject())
if savedModel:
return fname[0:len(fname)-4]
else:
print "Saving unsuccesfull!"
return
--- NEW FILE: __init__.py ---
from SfiManager import *
--- NEW FILE: python.iml ---
(ismw.metamodel.UML14
Model
p1
(dp2
S'isAbstract'
p3
I0
sS'isSpecification'
p4
I0
sS'__uniqueID__'
p5
S'i3af6dbe0141dc49e413e120e4051be18'
p6
sS'isRoot'
p7
I0
sS'visibility'
p8
[...27200 lines suppressed...]
I0
sg5
S'if1f5e220f72663332016cb25e518e381'
p4846
sg17
g4825
sg41
I0
sg4
I0
sg7
I0
sg8
I0
sg10
S'PyZipFile'
p4847
sg9
I0
sbasbsbasbsbasbsb.
|
|
From: <de...@us...> - 2004-01-07 01:48:33
|
Update of /cvsroot/pymerase/smw/smw/scw/UndoRedo
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/scw/UndoRedo
Added Files:
LayerManager.py SfiManager.py __init__.py python.iml
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: LayerManager.py ---
#!/usr/bin/env python2
__layer__ = 'UndoRedo'
import unittest
from smw.scw.Correctness import LayerManager as CorrectnessLayerManager
class LayerManager(CorrectnessLayerManager):
pass
--- NEW FILE: SfiManager.py ---
#!/usr/bin/env python2
__layer__ = 'UndoRedo'
"""This layer implements undo/redo operation;
all modifications of UML model made by LayerManager are expected to follow
well-formed rules
"""
from smw.metamodel.UML14 import *
from smw.Project import *
from LayerManager import LayerManager
from smw.scw.Correctness import SfiManager as CorrectnessSfiManager
class SfiManager(CorrectnessSfiManager):
def __init__(self,hist=None):
"""
Constructor for a new SfiManager.
"""
CorrectnessSfiManager.__init__(self)
self.__hist=None
self.__called=0
if hist:
self.__hist=hist
self.__called=1
else:
self.__proj = Project()
self.__hist=self.__proj.history
# self.__proj.setRoot(self.pythonPackage())
def setUp(self):
CorrectnessSfiManager.setUp(self)
self._layerManager=LayerManager()
def project(self):
return self.__proj
def history(self):
return self.__hist
def newProject(self, projectName = None):
project=CorrectnessSfiManager.newProject(self,projectName)
if project and not self.__called:
self.__proj.setRoot(project)
return project
def focusOnProject(self,project):
"""
Assigns the project given as parameter to current project and
returns the current project if the parameter is an existing project.
"""
rv=CorrectnessSfiManager.focusOnProject(self,project)
if (rv) and not self.__called:
self.__proj.setRoot(rv)
return rv
def newLayer(self,anc=None,succ=None,lname=None):
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
createdLayer=CorrectnessSfiManager.newLayer(self,anc,succ,lname)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return createdLayer
def newClass(self, newName=None):#tested - working - adding to current element, if it is a project or package
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
createdClass=CorrectnessSfiManager.newClass(self,newName)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return createdClass
def newInterface(self,newName=None):#tested-working - adding to current element, if it is a project or package
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
createdInterface=CorrectnessSfiManager.newInterface(self, newName)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return createdInterface
def newGeneralization(self,parent,child,newName=None):#tested -working, adding to closest common owner, class or interface
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
createdGeneralization=CorrectnessSfiManager.newGeneralization(self,parent,child,newName)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return createdGeneralization
def newAssociation(self,end1,end2,newName=None):#tested-working - adding to the closest common namespace,project or package.
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
createdAssociation=CorrectnessSfiManager.newAssociation(self,end1,end2,newName)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return createdAssociation
def newDependency(self,supplier,client,newName=None):#tested-working - adding to closest namespace, project or package
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
createdDependency=CorrectnessSfiManager.newDependency(self,supplier,client,newName)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return createdDependency
def newPackage(self,newName=None):#tested-working - adding to current element, if it is project or package
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
createdPackage=CorrectnessSfiManager.newPackage(self,newName)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return createdPackage
def newMethod(self,newName=None,specification=None):#tested-working - adding to currentElement and to the testClass
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
createdMethod=CorrectnessSfiManager.newMethod(self,newName,specification)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return createdMethod
def newOperation(self,newName=None):
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
createdOperation=CorrectnessSfiManager.newOperation(self,newName)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return createdOperation
def newAttribute(self,newName=None):#tested-working - adding to currentElement
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
createdAttribute=CorrectnessSfiManager.newAttribute(self,newName)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return createdAttribute
## def deleteElement1(self,element=None): #leaves the relationships hanging
## self.__proj.history.beginStrictTransaction()
## deletedElement=CorrectnessSfiManager.deleteElement1(self,element)
## #try:
## self.__proj.history.endTransaction()
## #except WFRException, e:
## # print 'WFR exception, undo impossible:\n%s' % e
## return deletedElement
def deleteElement2(self,element=None): #deletes the relationships too
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
deletedElement=CorrectnessSfiManager.deleteElement2(self,element)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return deletedElement
def renameElement(self, element, newName):#tested-working
"""
Renames the element to 'newName'
and returns the new name of the element.
Returns none if either one of the parameters is invalid.
"""
inModifyCmd=self.__hist.inModifyCmd
if not inModifyCmd:
self.__hist.beginStrictTransaction()
# sends the currentElement as parameter so that layerManager knows the current project
changedName=CorrectnessSfiManager.renameElement(self,element,newName)
#try:
if not inModifyCmd:
self.__hist.endTransaction()
#except WFRException, e:
# print 'WFR exception, undo impossible:\n%s' % e
return changedName
def undo(self):
"""
Undoes the previous operation done in layermanager.
-Current element reference is focused directly to the model.
"""
self.__hist.undo()
self.focusOnElement(self.currentProject())
def redo(self):
"""
Redoes the previous undone operation.
-Current element reference stays in the model regardeless the opertaion redo does.
"""
self.__hist.redo()
--- NEW FILE: __init__.py ---
from SfiManager import *
from LayerManager import *
--- NEW FILE: python.iml ---
(ismw.metamodel.UML14
Model
p1
(dp2
S'isAbstract'
p3
I0
sS'isSpecification'
p4
I0
sS'__uniqueID__'
p5
S'ib351d2ec95de35465f82789cf7689fa7'
p6
sS'isRoot'
p7
I0
sS'visibility'
p8
[...227897 lines suppressed...]
p49406
sg54
S''
sbsg4
I0
sg5
S'iaf81dd77ae2741edd072fd3d40fe0e99'
p49407
sg56
I0
sg8
I0
sg10
S'_normpath'
p49408
sg17
g48793
sg58
I0
sbasbsbasbsbasbsb.
|
|
From: <de...@us...> - 2004-01-07 01:48:33
|
Update of /cvsroot/pymerase/smw/smw/scw/CodeGen
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/scw/CodeGen
Added Files:
LayerManager.py SfiManager.py __init__.py python.iml
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: LayerManager.py ---
#!/usr/bin/env python2
__layer__ = 'CodeGen'
import unittest
from smw.scw.UndoRedo import LayerManager as UndoRedoLayerManager
class LayerManager(UndoRedoLayerManager):
pass
--- NEW FILE: SfiManager.py ---
#!/usr/bin/env python2
__layer__ = 'CodeGen'
from smw.metamodel import UML14 as metamodel
import unittest
import string
from LayerManager import LayerManager
from smw.transform.uml2py.uml2py import *
import os.path
import os
import sys
import popen2
from smw.metamodel.MetaMM import *
from smw.transform.modeltransformer import *
import tempfile
import time
from smw.scw.UndoRedo.SfiManager import SfiManager as UndoRedoSfiManager
class SfiManager(UndoRedoSfiManager):
def setUp(self):
UndoRedoSfiManager.setUp(self)
self._layerManager=LayerManager()
self.__codePaths={}
self.__returnCode="--**##\"\"#.-"
self.__tmpPath=None
self.__pythonIn='python2'
self.usedTmpPath=None
self.codeGenTimestamp={}
self.applicationTimestamp=0
self.methods=0
self.bidirect=0
self.pyth=1
self.methodPadding=1
self.classPadding=1
self.path=''
def returnCode(self):
return self.__returnCode
def deleteProject(self,name):
proj=UndoRedoSfiManager.deleteProject(self,name)
if proj:
if (self.__codePaths.has_key(proj)):
del self.__codePaths[proj]
if self.usedTmpPath:
if os.path.isdir(self.usedTmpPath):
popen2.popen2("rm -r "+self.usedTmpPath)
if self.codeGenTimestamp.has_key(proj.name):
del self.codeGenTimestamp[proj.name]
return proj
else:
return
def generateCode(self, path = None, bidirect=None,
pyth=None, methodPadding=None,
classPadding=None):
"""
Turns the currentProject UML model into .py files.
If path is not given, we will use the current working directory
If operation was succesful, the project object is returned, else None.
This operation also changes the timestamp of this file.
"""
if path==None:
path=self.path
if bidirect==None:
bidirect=self.bidirect
if pyth==None:
pyth=self.pyth
if methodPadding==None:
methodPadding=self.methodPadding
if classPadding==None:
classPadding=self.classPadding
if not self.currentProject():
ret="""
Congrats: you managed to do something that the creators of
this software didn't foresee. Please contact the developers
of the SFI editor.
"""
print ret
return ret
if path and ((os.path.isdir(path)) and not os.access(path,os.W_OK)):
print os.path.isdir(path)
ret="""
Current path in options is not valid: you don't have the
rights to modify the specified directory.
"""
print ret
return ret
if path and os.path.isfile(path):
ret="""
Current path in options is not valid: the specified path name
is already used by a normal file.
"""
print ret
return ret
eles=self._layerManager.returnElements(self.currentProject())
pnames=[]
for e in eles:
if e.oclIsKindOf(metamodel.Package) and not e.oclIsKindOf(metamodel.Model):
pnames.append(e.name)
if self.currentProject().name in pnames:
ret="""
At least one of the packages has the same name as the project.
Try to rename either the package or the project.
"""
print ret
return ret
e=None
try:
e=self.currentProject().isWellFormedRecursive()
except Exception,detail:
print detail
return detail
modifiedElements = []
modifiedPackages = {}
if self.codeGenTimestamp[self.currentProject().name]:
ts_flg = 0
for e in eles:
# check if there is later modified elements
# that has newer timestamp than codegentimestamp is
if self.codeGenTimestamp[self.currentProject().name] < e.__timestamp__:
ts_flg = 1
modifiedElements.append(e)
# add modified packages to the list
if e.oclIsKindOf(metamodel.Classifier):
modifiedPackages[e.namespace]=''
if e.oclIsKindOf(metamodel.Feature):
modifiedPackages[e.owner.namespace]=''
if e.oclIsKindOf(metamodel.Package):
modifiedPackages[e]=''
if not ts_flg:
ret = """
No need for code generation:
Current project has not been modified after
last code generation.
"""
print ret
return ret
elif not self.codeGenTimestamp[self.currentProject().name]:
modifiedPackages[self.currentProject()]=''
# remove such packages that are inside other packages that are generated
for pack in modifiedPackages.keys():
ns=pack
while not ns.oclIsKindOf(metamodel.Model):
ns=ns.namespace
if ns in modifiedPackages.keys():
if modifiedPackages.has_key(pack):
del modifiedPackages[pack]
break
modifiedPackages[pack]=ns.name+'/'+modifiedPackages[pack]
###
## savename = "gc"
## x = 1
## while (os.path.isfile(savename + str(x) + ".iml")): # create unique file name
## x = x+1
## savename = savename + str(x)+".iml"
## check=self.saveProjectAs(savename)
## if (check == None): # something went wrong.
## return None
#argv = ["python", "uml2py.py", "--input",savename, "--output", "."]
#runner=cmdlinemtr.CmdLineMTRunner(UML2Py(),argv[1:])
## possibleError = runner.doit()
## if (possibleError == -1):
## return None
## try:
## os.remove(savename) # remove the tmp file
## except: # Makes sure that the program wont crash if the file is in use for some reason.:
## pass
if pyth:
self.__pythonIn='python2'
else:
self.__pythonIn='python1.5'
if not path:
#if not self.__tmpPath:
self.__tmpPath=tempfile.mktemp()
self.usedTmpPath=self.__tmpPath
#else:
#popen2.popen2("rm -r "+self.__tmpPath)
#FIXME
#pass
else:
self.__tmpPath=path
sys.path.append(self.__tmpPath)
u2p=UML2Py()
u2p.bidirectAssoc=bidirect
u2p.methodPadding=methodPadding
u2p.classPadding=classPadding
u2p.model=self.currentProject()
u2p.metamodel=MetaMM.getMetamodelByName(u2p.model.__module__)
if bidirect:
c=PythonCodeArtifact(self.__tmpPath+'/'+self.currentProject().name+'/'+UML2Py._UMLClassModule)
c.addText(UML2Py._umlcoresupport(u2p))
c.save()
for pack in modifiedPackages:
sys.__stdout__.write(pack.name)
code=UML2Py.processPackage(u2p,pack,self.__tmpPath+'/'+modifiedPackages[pack])
if code:
code.save()
self.__codePaths[self.currentProject()]=self.__tmpPath+"/"
self.codeGenTimestamp[self.currentProject().name] = time.time()
return self.currentProject() # return the project if operation was succesfull
def isCodeGenerated(self):
eles=self._layerManager.returnElements(self.currentProject())
for e in eles:
if self.codeGenTimestamp[self.currentProject().name] < e.__timestamp__:
return 0
return 1
def renameElement(self,element,newName):
self.history().beginStrictTransaction()
changedName=UndoRedoSfiManager.renameElement(self,element,newName)
app=element.taggedValue.select(lambda x:x.name=="application")
if changedName and len(app)==1:
self.setApplication(element)
self.history().endTransaction()
def setApplication(self,applicationClass,parameters=""):
if(not self.currentProject()):
return
elements=self._layerManager.returnElements(self.currentProject())
if (applicationClass in elements):
for x in elements:
if(isinstance(x,metamodel.Class)):
for y in x.taggedValue.select(lambda z: z.name=="application"):
self._layerManager.detachTag(y)
instRow=parameters
ns=applicationClass.namespace
p=ns.name
while not ns==self.currentProject():
ns=ns.namespace
p=ns.name+'.'+p
stri="#!/usr/bin/env "+self.__pythonIn+' '+self.__returnCode+"from "+p+" import "+applicationClass.name+self.__returnCode+instRow
self._layerManager.attachTag(applicationClass,"application",stri)
return applicationClass
def execute(self,qprocess=None):
#chekkaa onko koodi generoitu....
if(self.__codePaths.has_key(self.currentProject())):
#Mitä tehdään?...pitäisi nostaa dialogi
#return None
# Avataan samassa hakemistossa kuin minne itse koodi generoidaan
path=self.__codePaths[self.currentProject()]
elements=self._layerManager.returnElements(self.currentProject())
applicationTagValue=None
applicationTag=None
for x in elements:
if isinstance(x,metamodel.Class):
for y in x.taggedValue.select(lambda z: z.name=="application"):
applicationTagValue=y.dataValue
applicationTag=y
if not applicationTag:
return
if applicationTag.__timestamp__>self.applicationTimestamp:
# pitäisi tietää minne directoryyn pistetään
runFile=open(self.__tmpPath+"/runme.py","w")
tagValues=string.split(applicationTagValue,self.__returnCode)
for i in tagValues:
runFile.write(i+"\n")
runFile.close()
self.applicationTimestamp=applicationTag.__timestamp__
# runs the program
if qprocess:
qprocess.addArgument(self.__pythonIn)
qprocess.addArgument(self.__tmpPath+"/runme.py")
qprocess.start()
return
else:
# [out,y,err]=popen2.popen3(os.spawnlp(os.P_NOWAIT,"python","",self.__tmpPath+"/runme.py"))
[out,y,err]=popen2.popen3(self.__pythonIn+' '+self.__tmpPath+"/runme.py")
errors=0
res=""
while 1:
t=err.readline()
if (t==""):
break
res=res+t
errors=1
if not errors:
while 1:
s=out.readline()
if (s==""):
break
res=res+s
print res
return res
def runTest(self,testCaseClass,qprocess=None):
print "calling runTest"
if not self.__codePaths.has_key(self.currentProject()):
return
if not testCaseClass or testCaseClass==[]:
return
ok=1
for x in testCaseClass:
if not(x in self._layerManager.returnElements(self.currentProject())):
ok=0
if ok:
path=self.__codePaths[self.currentProject()]
runFile=open(self.__tmpPath+"/runTest.py","w")
runFile.write("#!/usr/lib/env "+self.__pythonIn+"\n")
runFile.write("import unittest\n")
for x in testCaseClass:
importFlag=0
inheritFlag=0
ownerElement=x.namespace
for y in ownerElement.clientDependency.select(lambda z: z.supplier[0].name=="unittest"):
importFlag=1
break
if importFlag:
packChain=""
iterator=x
while 1:
if(iterator.namespace==None):
if packChain[-1]==".":
packChain=packChain[:-1]
break
else:
packChain=iterator.namespace.name+"."+packChain
iterator=iterator.namespace
runFile.write("from "+packChain+" import "+x.name+"\n\n")
runFile.write("unittest.main()\n")
runFile.close()
if qprocess:
qprocess.addArgument(self.__pythonIn)
qprocess.addArgument(self.__tmpPath+"/runTest.py")
qprocess.start()
return
else:
if 1:
[o1,y1,result]=popen2.popen3(self.__pythonIn+' '+self.__tmpPath+"/runTest.py")
errors=0
ticker=0
counter=0
res=""
while 1:
t = o1.readline()
if (t==""):
break
res=res+t
while 1:
t=result.readline()
if (t==""):
break
if ticker:
counter+=1
if (string.find(t,"ImportError")>=0):
errors=1
if (string.find(t,"SyntaxError")>=0):
errors=1
if (string.find(t,"Ran ")==0 and string.find(t," tests in ")>0):
ticker=1
if counter==2:
if string.find(t,"FAILED")==0:
errors=1
res=res+t
# popen2.popen2("rm runTest.py")
text=""
# update the correctness tag in class
if errors==0:
text="test passed"
print text
for x in testCaseClass:
cl=self.layerManager().getTestSupplier(x)
self.updateModelTags(cl,0)
else:
text="test failed"
print text
for x in testCaseClass:
cl=self.layerManager().getTestSupplier(x)
self.updateModelTags(cl,1)
for x in testCaseClass:
clas=self._layerManager.getTestSupplier(x)
if clas:
for x in clas.taggedValue.select(lambda z: z.name=="correctness"):
x.dataValue=text
print res
return res
def checkForErrors(self,message,element):
mes=string.split(message,"\n")
errors=0
ticker=0
counter=0
for z in mes:
t=z
if ticker:
counter+=1
if (string.find(t,"NameError")>=0):
errors=1
if (string.find(t,"FAILED (")>0):
errors=1
if (string.find(t,"ImportError")>=0):
errors=1
if (string.find(t,"SyntaxError")>=0):
errors=1
if (string.find(t,"ERROR")>=0):
errors=1
if (string.find(t,"Ran ")==0 and string.find(t," tests in ")>0):
ticker=1
if counter==2:
if string.find(t,"FAILED")==0:
errors=1
text=""
pText=""
if errors==0:
text="test passed"
pText="all tests passed"
self.updateModelTags(element,0)
else:
text="test failed"
pText="some tests failed"
self.updateModelTags(element,1)
if isinstance(element,metamodel.Class):
for x in element.taggedValue.select(lambda z: z.name=="correctness"):
x.dataValue=text
return
else:
for x in element.taggedValue.select(lambda z: z.name=="correctness" ):
x.dataValue=pText
eles=self.layerManager().recursiveElements(element)
for x in eles:
for y in x.taggedValue.select(lambda z: z.name=="correctness" ):
if isinstance(element,metamodel.Class):
y.dataValue=text
elif isinstance(element,metamodel.Package):
y.dataValue=pText
def runAllTestsInPackage(self,p,qprocess=None):
elemList=self._layerManager.recursiveElements(p)
result=""
els=[]
for el in elemList:
if isinstance(el,metamodel.Class) and not self.layerManager().isTestClass(el):
els.append(self.layerManager().getTestClient(el))
if els:
some=self.runTest(els,qprocess)
result=some
return result
def runAllTests(self,qprocess=None):
elementList=self._layerManager.returnElements(self.currentProject())
result=''
els=[]
for el in elementList:
for tag in el.taggedValue.select(lambda z: z.name=="testcase"):
els.append(el)
if els:
some=self.runTest(els,qprocess)
result=some
return result
def updateModelTags(self,Class,failed):
# eli jos failasi
if not Class:
return
ele=Class
if failed:
running=1
while ele.namespace and running:
if ele.namespace.oclIsKindOf(metamodel.Model):
for x in ele.namespace.taggedValue.select(lambda z: z.name=="correctness"):
x.dataValue="some tests failed"
running=0
else:
for x in ele.namespace.taggedValue.select(lambda z: z.name=="correctness" ):
x.dataValue="some tests failed"
ele=ele.namespace
else:
undef=0
correct=1
while ele.namespace and correct:
ele=ele.namespace
for x in ele.ownedElement:
if x!=Class:
for y in x.taggedValue.select(lambda z: z.name=="correctness"):
if y.dataValue=="some tests failed" or y.dataValue=="test failed":
correct=0
if y.dataValue=="undefined":
undef=1
if correct:
if not undef:
for x in ele.taggedValue.select(lambda z: z.name=="correctness"):
x.dataValue="all tests passed"
else:
for x in ele.taggedValue.select(lambda z: z.name=="correctness" ):
x.dataValue="undefined"
def newProject(self, projectName = None):
p=UndoRedoSfiManager.newProject(self,projectName)
if p:
self.codeGenTimestamp[p.name]=0
return p
def loadProject(self, fname):
p=UndoRedoSfiManager.loadProject(self, fname)
if p:
self.codeGenTimestamp[p.name]=0
return p
def renameProject(self, oldName, newName):
p=UndoRedoSfiManager.renameProject(self,oldName, newName)
if p:
self.codeGenTimestamp[p]=self.codeGenTimestamp[oldName]
del self.codeGenTimestamp[oldName]
return p
def updateCorrectnessTag(self):
fail=0
undef=0
cl=[]
el=self._layerManager.returnElements(self.currentProject())
for i in el:
if isinstance(i,metamodel.Classifier):
ns=i.namespace
inpp=None
while not ns==self.currentProject():
if ns.name=='python2_2':
inpp=1
ns=self.currentProject()
else:
ns=ns.namespace
if not inpp:
if isinstance(i,metamodel.Class) and not self._layerManager.isTestClass(i):
cl.append(i)
for c in cl:
ns=c.namespace
while ns:
fail=0
undef=0
for x in ns.ownedElement:
for y in x.taggedValue.select(lambda z: z.name=="correctness" ):
if y.dataValue=="some tests failed" or y.dataValue=="test failed":
fail=1
if not fail:
for y in x.taggedValue.select(lambda z: z.name=="correctness"):
if y.dataValue=="undefined":
undef=1
for t in ns.taggedValue.select(lambda z: z.name=="correctness"):
if undef and not fail:
t.dataValue="undefined"
elif fail:
t.dataValue="some tests failed"
else:
t.dataValue="all tests passed"
ns=ns.namespace
--- NEW FILE: __init__.py ---
from SfiManager import *
from LayerManager import *
--- NEW FILE: python.iml ---
(ismw.metamodel.UML14
Model
p1
(dp2
S'isAbstract'
p3
I0
sS'isSpecification'
p4
I0
sS'__uniqueID__'
p5
S'i3af6dbe0141dc49e413e120e4051be18'
p6
sS'isRoot'
p7
I0
sS'visibility'
p8
[...27200 lines suppressed...]
I0
sg5
S'if1f5e220f72663332016cb25e518e381'
p4846
sg17
g4825
sg41
I0
sg4
I0
sg7
I0
sg8
I0
sg10
S'PyZipFile'
p4847
sg9
I0
sbasbsbasbsbasbsb.
|
|
From: <de...@us...> - 2004-01-07 01:48:30
|
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]
|
|
From: <de...@us...> - 2004-01-07 01:48:30
|
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)
|
|
From: <de...@us...> - 2004-01-07 01:48:30
|
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]
|
|
From: <de...@us...> - 2004-01-07 01:48:30
|
Update of /cvsroot/pymerase/smw/smw/scw/Correctness
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/scw/Correctness
Added Files:
LayerManager.py SfiManager.py __init__.py
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: LayerManager.py ---
#!/usr/bin/env python2
__layer__ = 'Correctness'
import unittest
from smw.scw.Layer import LayerManager as LayerLayerManager
class LayerManager(LayerLayerManager):
pass
--- NEW FILE: SfiManager.py ---
#!/usr/bin/env python2
"""
This layer adds the correctness tag to the elements
"""
__layer__ = 'Correctness'
from smw.metamodel import UML14 as metamodel
from LayerManager import LayerManager
from smw.scw.Layer.SfiManager import SfiManager as LayerSfiManager
class SfiManager(LayerSfiManager):
def newProject(self, projectName=None):
"""
Adds the correctness tag to the project, defaultvalue:'undefined'
"""
project=LayerSfiManager.newProject(self,projectName)
if project:
self.layerManager().attachTag(project,"correctness","undefined")
self.updateUndef(project)
return project
def newLayer(self,anc=None,succ=None,lname=None):
"""
Adds the correctness tag to the layer, defaultvalue:'undefined'
"""
layer=LayerSfiManager.newLayer(self,anc,succ,lname)
if layer:
self.layerManager().attachTag(layer,"correctness","undefined")
self.updateUndef(layer)
return layer
def newClass(self,newName=None):
"""
Adds the correctness tag to the class, defaultvalue:'undefined'
"""
createdClass=LayerSfiManager.newClass(self,newName)
if createdClass:
self.layerManager().attachTag(createdClass,"correctness","undefined")
self.updateUndef(createdClass)
self.attachSuccessorTags(createdClass)
return createdClass
def newPackage(self,newName=None):
"""
Adds the correctness tag to the package, defaultvalue:'undefined'
"""
createdPackage=LayerSfiManager.newPackage(self,newName)
if createdPackage:
self.layerManager().attachTag(createdPackage,"correctness","undefined")
self.updateUndef(createdPackage)
self.attachSuccessorTags(createdPackage)
return createdPackage
def updateUndef(self,ele):
"""
Method for updating all the elements below the created element
"""
while ele.namespace:
ele=ele.namespace
for x in ele.taggedValue:
if x.name=="correctness":
x.dataValue="undefined"
def attachSuccessorTags(self,element):
""" Attaches the correctness tags to all successor (packages,interfaces,classes).
_not_ to layers. """
if not self.layerManager().inLayer(element):
return
if isinstance(element,metamodel.Package):
lpDeps=element.supplierDependency.select( \
lambda x: self.layerManager().isLayerPackageDependency(x))
for d in lpDeps:
p=d.client[0]
if not p.taggedValue.select(lambda x: x.name=="correctness"):
self.layerManager().attachTag(p,"correctness","undefined")
self.updateUndef(p)
self.attachSuccessorTags(p)
if isinstance(element,metamodel.Classifier) \
and not self.layerManager().isTestClass(element):
lGens=element.specialization.select( \
lambda x: isinstance(x.child,type(element))
and x.child.name==element.name
and x.name[0:8]=="layerGen")
for g in lGens:
e=g.child
if not e.taggedValue.select(lambda x: x.name=="correctness"):
self.layerManager().attachTag(e,"correctness","undefined")
self.updateUndef(e)
self.attachSuccessorTags(e)
def loadProject(self,fname):
"""
If the element doesn't have the correctness tag when loading, it adds it.
"""
loader=LayerSfiManager.loadProject(self,fname)
if loader:
ele=self.layerManager().returnElements(loader)
for el in ele:
if (el.oclIsKindOf(metamodel.Package) or el.oclIsKindOf(metamodel.Classifier)) and not self.layerManager().isTestClass(el):
inpp=None
if not (el.oclIsKindOf(metamodel.Model)):
ns=el.namespace
while not ns==loader:
if ns.name=='python2_2':
inpp=1
ns=loader
else:
ns=ns.namespace
if (not inpp or el.oclIsKindOf(metamodel.Model)) and not el.name=="python2_2":
tagNames=[]
for i in el.taggedValue:
tagNames.append(i.name)
if not "correctness" in tagNames:
self.layerManager().attachTag(el,"correctness","undefined")
return loader
--- NEW FILE: __init__.py ---
from SfiManager import *
from LayerManager import *
|
|
From: <de...@us...> - 2004-01-07 01:48:29
|
Update of /cvsroot/pymerase/smw/smw/scw/Element/unittests
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/scw/Element/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__ = 'Element'
import unittest
from smw.metamodel import UML14 as metamodel
from smw.metamodel.UML14 import *
from smw.scw.Element.LayerManager import *
#from smw.scw.Element.SfiManager import SfiManager
from posixpath import exists
import tempfile
from smw.scw.Project.unittests.testSfiManager import mkUniqueStr
def mkUniqueProjectName():
s = tempfile.mktemp()
s = s + 'SFI_project'
return s
def mkUniqueLayerName():
[...1825 lines suppressed...]
self.assert_(self.lMan.isTestClass(tC),'should be true')
self.assert_(not self.lMan.isTestClass(c),'not true')
# not just tag is tested
c=self.lMan.newClass(self.model,mkUniqueStr())
self.assert_(c,'class was not created')
self.lMan.attachTag(c,'testcase')
self.assert_(not self.lMan.isTestClass(c),'None was not returned')
def testCreateUniqueElementName(self):
N=5
for x in range(N):
c=self.lMan.newClass(self.model,self.lMan.createUniqueElementName(self.model,"class"))
self.assert_(c,'Class was not created.')
self.assert_(c.name=="class"+str(x+1),'Wrong name for the class')
if __name__ == '__main__':
#obj2test=SfiManager()
#LayerManagerObject = LayerManager()
unittest.main()
--- NEW FILE: testSfiManager.py ---
#!/usr/bin/env python2
__layer__ = 'Element'
import unittest
from smw.metamodel import UML14 as metamodel
#from testLayerManager import mkUniqueStr
from smw.scw.Project.unittests.testSfiManager import mkUniqueStr
from smw.scw.Element.SfiManager import SfiManager
from smw.scw.Project.unittests.testSfiManager import testSfiManager as ProjectTestSfiManager
from smw.io import *
from smw.scw.Element.LayerManager import mkTestCaseName,mkTestMethodName
class testSfiManager(ProjectTestSfiManager):
#class testSfiManager(unittest.TestCase):
def setUp(self):
self.sMan = obj2test
[...2069 lines suppressed...]
c=d.client.select(lambda x: x.name==i.name)
self.assert_(c,"Wrong client for the dependency.")
# Some incorrect values:
self.sMan.focusOnElement(project)
items=[None,mkUniqueStr(),lMan.newClass(project,mkUniqueStr())]
c=len(self.sMan.layerManager().returnElements(project))
for i in items:
r=self.sMan.addUnittestDependency(i)
self.assert_(not r, "Dependency was incorrectly created and returned.")
self.assert_(c==len(self.sMan.layerManager().returnElements(project)),"Dependency was added.")
if __name__ == '__main__':
obj2test = SfiManager()
suite = unittest.TestLoader().loadTestsFromTestCase(testSfiManager)
unittest.TextTestRunner().run(suite)
#unittest.main()
|
Update of /cvsroot/pymerase/smw/smw/sart/metamodel
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/sart/metamodel
Added Files:
SART.py SARTModel.smw SARTModel.xml SARTtemplate.py
__init__.py makefile
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: SART.py ---
from __future__ import nested_scopes
import copy
from smw.metamodel.MetaMM import *
MMFullName='SART 0.1'
MMVersion='0.1'
MMName='SART'
class PromptKind(MMEnumeration):
pk_enable=0
pk_trigger=1
description=[u'enable/disable', u'trigger']
class FlowKind(MMEnumeration):
fk_discrete=0
fk_continous=1
description=[u'discrete', u'continous']
[...1089 lines suppressed...]
'flow': (MMClass.kind__Association,ControlFlow,0,'event',0,0),
'state': (MMClass.kind__Association,State,0,'deferrableEvent',0,0),
'store': (MMClass.kind__Association,ControlStore,0,'contents',0,0),
'name': (MMClass.kind__Attribute,Name,1,None,None,0),
'presentation': (MMClass.kind__Composition,PresentationElement,0,'subject',0,0),
'comment': (MMClass.kind__Association,Comment,0,'element',0,0),
'constraint': (MMClass.kind__Association,Constraint,0,'constrainedElement',0,0),
'namespace': (MMClass.kind__Association,Namespace,1,'ownedElement',0,0)
}
Association.__subclasses__=[Flow, DataFlow, ControlFlow, PromptFlow]
Association.__mm__={
'connection': (MMClass.kind__Composition,AssociationEnd,0,'association',1,0),
'name': (MMClass.kind__Attribute,Name,1,None,None,0),
'presentation': (MMClass.kind__Composition,PresentationElement,0,'subject',0,0),
'comment': (MMClass.kind__Association,Comment,0,'element',0,0),
'constraint': (MMClass.kind__Association,Constraint,0,'constrainedElement',0,0),
'namespace': (MMClass.kind__Association,Namespace,1,'ownedElement',0,0)
}
--- NEW FILE: SARTModel.smw ---
SMW_MODEL
METAMODEL smw.metamodel.UML14
PROFILE UML14
(ismw.metamodel.UML14
Model
p1
(dp2
S'isAbstract'
p3
I0
sS'isSpecification'
p4
I0
sS'__uniqueID__'
p5
S'DCE:D712E5F8-CF96-11D6-B84D-0004768CE271'
p6
sS'modulestring'
p7
[...49415 lines suppressed...]
(ismw.metamodel.MetaMM
MMAssociationEnd
p9242
(dp9243
g16
(I3
g79
I0
g80
I0
I0
tp9244
sg20
g76
sg21
g1
sg22
(lp9245
g5869
asbsb.
--- NEW FILE: SARTModel.xml ---
<?xml version='1.0' encoding='ISO-8859-15'?>
<XMI xmi.version='1.1' timestamp='Wed, 06 Nov 2002 10:20:54 +0200'>
<XMI.header>
<XMI.metamodel xmi.name="UML" xmi.version='1.4'/>
</XMI.header>
<XMI.content>
<UML:Model xmi.id='DCE:D712E5F8-CF96-11D6-B84D-0004768CE271' xmi.uuid='DCE:D712E5F8-CF96-11D6-B84D-0004768CE271' isAbstract="false" isSpecification="false" visibility="public" isLeaf="false" isRoot="false" name="UntitledModel">
<UML:Namespace.ownedElement>
<UML:Package xmi.id='DCE:DCA5B0AC-CF96-11D6-B84D-0004768CE271' xmi.uuid='DCE:DCA5B0AC-CF96-11D6-B84D-0004768CE271' isAbstract="false" isSpecification="false" namespace="DCE:D712E5F8-CF96-11D6-B84D-0004768CE271" visibility="public" isLeaf="false" isRoot="false" name="Core">
<UML:Namespace.ownedElement>
<UML:Class xmi.id='DCE:0ECB98DA-CF97-11D6-B84D-0004768CE271' xmi.uuid='DCE:0ECB98DA-CF97-11D6-B84D-0004768CE271' isAbstract="true" isSpecification="false" isRoot="false" visibility="public" name="Element" namespace="DCE:DCA5B0AC-CF96-11D6-B84D-0004768CE271" isActive="false" isLeaf="false">
<UML:GeneralizableElement.specialization>
<UML:Generalization xmi.idref='DCE:0CCFE8A0-CF98-11D6-B84D-0004768CE271'/>
<UML:Generalization xmi.idref='DCE:E255E66A-CFA6-11D6-B84D-0004768CE271'/>
<UML:Generalization xmi.idref='DCE:E28CC630-CFA6-11D6-B84D-0004768CE271'/>
<UML:Generalization xmi.idref='DCE:E28E9262-CFA6-11D6-B84D-0004768CE271'/>
<UML:Generalization xmi.idref='DCE:1D17591E-CFA7-11D6-B84D-0004768CE271'/>
</UML:GeneralizableElement.specialization>
</UML:Class>
[...1533 lines suppressed...]
<UML:Generalization xmi.id='DCE:4B284A3A-CFA6-11D6-B84D-0004768CE271' xmi.uuid='DCE:4B284A3A-CFA6-11D6-B84D-0004768CE271' isSpecification="false" child="DCE:61B9BD6C-CFA4-11D6-B84D-0004768CE271" visibility="public" discriminator="" parent="DCE:1009873E-CF97-11D6-B84D-0004768CE271" name="">
</UML:Generalization>
<UML:Generalization xmi.id='DCE:0FC1C2E8-E64C-11D6-868C-0004768CE271' xmi.uuid='DCE:0FC1C2E8-E64C-11D6-868C-0004768CE271' isSpecification="false" child="DCE:6742C36E-E5AC-11D6-868C-0004768CE271" visibility="public" discriminator="" parent="DCE:5E362900-CFA4-11D6-B84D-0004768CE271" name="">
</UML:Generalization>
<UML:Generalization xmi.id='DCE:4CE3555E-CFA6-11D6-B84D-0004768CE271' xmi.uuid='DCE:4CE3555E-CFA6-11D6-B84D-0004768CE271' isSpecification="false" child="DCE:60D01556-CFA4-11D6-B84D-0004768CE271" visibility="public" discriminator="" parent="DCE:1009873E-CF97-11D6-B84D-0004768CE271" name="">
</UML:Generalization>
<UML:Generalization xmi.id='DCE:E255E66A-CFA6-11D6-B84D-0004768CE271' xmi.uuid='DCE:E255E66A-CFA6-11D6-B84D-0004768CE271' isSpecification="false" child="DCE:A208AA98-CFA6-11D6-B84D-0004768CE271" visibility="public" discriminator="" parent="DCE:0ECB98DA-CF97-11D6-B84D-0004768CE271" name="">
</UML:Generalization>
<UML:Generalization xmi.id='DCE:181D8640-E64C-11D6-868C-0004768CE271' xmi.uuid='DCE:181D8640-E64C-11D6-868C-0004768CE271' isSpecification="false" child="DCE:79338BC6-E5AC-11D6-868C-0004768CE271" visibility="public" discriminator="" parent="DCE:03C2BA06-E5AC-11D6-868C-0004768CE271" name="">
</UML:Generalization>
<UML:Generalization xmi.id='DCE:89BEA7F2-EE33-11D6-9845-0004768CE271' xmi.uuid='DCE:89BEA7F2-EE33-11D6-9845-0004768CE271' isSpecification="false" child="DCE:11545844-CF97-11D6-B84D-0004768CE271" visibility="public" discriminator="" parent="DCE:1009873E-CF97-11D6-B84D-0004768CE271" name="">
</UML:Generalization>
<UML:Generalization xmi.id='DCE:E28CC630-CFA6-11D6-B84D-0004768CE271' xmi.uuid='DCE:E28CC630-CFA6-11D6-B84D-0004768CE271' isSpecification="false" child="DCE:A208AA98-CFA6-11D6-B84D-0004768CE271" visibility="public" discriminator="" parent="DCE:0ECB98DA-CF97-11D6-B84D-0004768CE271" name="">
</UML:Generalization>
<UML:Generalization xmi.id='DCE:187D57EE-E64C-11D6-868C-0004768CE271' xmi.uuid='DCE:187D57EE-E64C-11D6-868C-0004768CE271' isSpecification="false" child="DCE:79338BC6-E5AC-11D6-868C-0004768CE271" visibility="public" discriminator="" parent="DCE:03C2BA06-E5AC-11D6-868C-0004768CE271" name="">
</UML:Generalization>
</UML:Namespace.ownedElement>
</UML:Model>
</XMI.content>
</XMI>
--- NEW FILE: SARTtemplate.py ---
class FlowKind(MMEnumeration):
fk_discrete=0
fk_continous=1
description=[u'discrete', u'continous']
class PromptKind(MMEnumeration):
pk_enable=0
pk_trigger=1
description=[u'enable/disable', u'trigger']
class Transition:
def getDescription(self):
text=''
if self.trigger:
text=self.trigger.name
if self.guard:
text=text+'['+self.guard.guardExpression.body+']'
if self.effect:
text=text+'/'+self.effect.effect.body
return text
class Constraint:
def wfrConstraint1(self):
"A Constraint cannot be applied to itself"
return not(self.constrainedElement.includes(self))
class Classifier:
def getOutgoingAssociationEnds(self):
"Returns the outgoing associationEnds from a Classifier"
return (self.association.select(lambda ae: not (ae.isNavigable)))
def getIncomingAssociationEnds(self):
"Returns the outgoing associationEnds from a Classifier"
return (self.association.select(lambda ae: ae.isNavigable))
def getAssociations(self):
"Returns all associations connected to a Classifier"
myAss=MMSet()
for x in self.association:
myAss.insert(x.association)
return myAss
def getConnectedClassifiers(self):
"Returns all other classifiers connected to this classifier through Flows"
myAss=self.getAssociations()
connected=MMSet()
for x in myAss:
for y in x.connection:
if not (y.participant == self):
connected.insert(y.participant)
return connected
class AssociationEnd:
def wfrAssociationEnd1(self):
"AssociationEnds are unnamed"
return (self.name=="")
class Flow:
def isRefinementFlow(self, refinedElement):
"Returns true if the flow connects a refined element and its refiner"
for x in self.connection:
if refinedElement.includedElements.includes(x.participant):
return 1
return 0
def wfrFlow1(self):
"Flows may not have the same source and target elements"
return (self.connection.forAll(
lambda ae1,ae2: implies((ae1.participant==ae2.participant), ae1==ae2)))
def wfrFlow2(self):
"Flows connected to Stores are unnamed"
return (self.connection.forAll(lambda a: implies(isinstance(a.participant,Store)),
a.participant.name==""))
class FlowModifier:
def existsConnectedDataFlows(self):
"Returns true if there are DataFlows connected to this FlowModifier"
ownAss = MMSet()
for x in self.association:
if x.association.oclIsKindOf(DataFlow):
ownAss.insert(x.association)
return (ownAss.size()>0)
def existsConnectedControlFlows(self):
"Returns true if there are ControlFlows connected to this FlowModifier"
ownAss = MMSet()
for x in self.association:
if x.association.oclIsKindOf(ControlFlow):
ownAss.insert(x.association)
return (ownAss.size()>0)
def existsConnectedPromptFlows(self):
"Returns true if there are PromptFlows connected to this FlowModifier"
ownAss = MMSet()
for x in self.association:
if x.association.oclIsKindOf(PromptFlow):
ownAss.insert(x.association)
return (ownAss.size()>0)
def wfrModifier1(self):
"A FlowModifier can only have one kind of Flows connected to itself"
ownAss = MMSet()
for x in self.association:
ownAss.insert(x.association)
return (ownAss.forAll(lambda a: a.oclIsKindOf(DataFlow))
or ownAss.forAll(lambda a: a.oclIsKindOf(ControlFlow))
or ownAss.forAll(lambda a: a.oclIsKindOf(PromptFlow)))
def wfrModifier2(self):
"A FlowModifier can only have discrete or continous Flows connected to itself"
ownAss = MMSet()
for x in self.association:
ownAss.insert(x.association)
return (ownAss.forAll(lambda a: a.type==FlowKind.fk_discrete)
or ownAss.forAll(lambda a: a.type==FlowKind.fk_continous))
class Split:
def wfrSplit1(self):
"A Split has exactly one incoming and at least two outgoing AssociationEnds"
return ((self.getIncomingAssociationEnds().size()==1) and
(self.getOutgoingAssociationEnds().size()>=2))
class CloneSplit:
def wfrCloneSplit1(self):
"Outgoing flows from a Clonesplits are unnamed"
return((self.getOutgoingAssociationEnds().
forAll(lambda a: a.association.name=="")))
class Join:
def wfrJoin1(self):
"A Join has at least two incoming and exactly one outgoing AssociationEnd"
return ((self.getIncomingAssociationEnds().size()>=2) and
(self.getOutgoingAssociationEnds().size()==1))
class OrJoin:
def wfrOrJoin1(self):
"Incoming flows to an OrJoin are unnamed"
return((self.getIncomingAssociationEnds().
forAll(lambda a: a.association.name=="")))
class Transformation:
def wfrTransformation1(self):
"All Transformations must have both incoming and outgoing Flows"
return (self.getIncomingAssociationEnds().size()>0 and
self.getOutgoingAssociationEnds().size()>0)
class ControlTransformation:
def wfrControlTransformation1(self):
"A ControlTransformation can have only ControlFlows as inputs and outputs"
return (self.association.forAll(
lambda ae: ae.association.oclIsKindOf(ControlFlow)))
class ExternalEntity:
def wfrExternalEntity1(self):
"An ExternalEntity may only be connected to top-level DataTransformations"
return(self.getConnectedClassifiers().
forAll(lambda c: c.oclIsKindOf(DataTransformation) and
c.namespace.oclIsKindOf(Model)))
class DataTransformation:
def wfrDataTransformation1(self):
"A non-abstract DataTransformation can have only DataFlows or PromptFlows as inputs"
if (self.includedElements.size()>0):
return True
else:
return(self.getIncomingAssociationEnds().forAll(
lambda ae: (ae.association.oclIsKindOf(DataFlow)) or
ae.association.oclIsKindOf(PromptFlow)))
class Store:
def wfrStore1(self):
"A Store may only be connected to a Transformation"
return(self.getConnectedClassifiers().forAll
(lambda c: c.oclIsKindOf(Transformation)))
class DataStore:
def wfrDataStore1(self):
"A DataStore may only be connected to DataFlows"
return(self.association.forAll(
lambda ae: ae.association.oclIsKindOf(DataFlow)))
class ControlStore:
def wfrControlStore1(self):
"A ControlStore may only be connected to ControlFlows"
return(self.association.forAll(
lambda ae: ae.association.oclIsKindOf(ControlFlow)))
class PromptFlow:
def wfrPromptFlow1(self):
"A PromptFlow may contain either one event named 'trigger' or two events named 'enable' and 'disable'"
return((self.event.size()==1 and self.event.includes(lambda a: a.name=="trigger")) or
(self.event.size()==2 and self.event.includes(lambda a: a.name=="enable") and
self.event.includes(lambda a: a.name=="disable")))
def wfrPromptFlow2(self):
"A PromptFlow must be discrete"
return (self.type==FlowKind.fk_discrete)
def wfrPromptFlow3(self):
"All PromptFlows are unidirectional"
return (self.connection.forAll(
lambda ae1,ae2: implies((ae1.isNavigable == ae2.isNavigable),ae1==ae2)))
class CompositeState:
def wfrCompositeState1(self):
"A composite state can have at most one initial vertex"
return self.subvertex.select(
lambda v: v.oclIsKindOf(Pseudostate) and v.kind== PseudostateKind.pk_initial).size() <=1
def wfrCompositeState2(self):
"A composite state can have at most one deep history vertex"
return self.subvertex.select(
lambda v: v.oclIsKindOf(Pseudostate) and v.kind== PseudostateKind.pk_deepHistory).size() <=1
def wfrCompositeState3(self):
"A composite state can have at most one shallow history vertex"
return self.subvertex.select(
lambda v: v.oclIsKindOf(Pseudostate) and v.kind== PseudostateKind.pk_shallowHistory).size() <=1
def wfrCompositeState4(self):
"There have to be at least two composite substates in a concurrent composite state"
return implies(self.isConcurrent,
self.subvertex.select(lambda v:
v.oclIsKindOf(CompositeState)).size()>=2)
def wfrCompositeState5(self):
"A concurrent state can only have composite states as substates"
return implies(self.isConcurrent,
self.subvertex.forAll(lambda s:
s.oclIsKindOf(CompositeState)))
def wfrCompositeState6(self):
"The substates of a composite state are part of only that composite state"
return self.subvertex.forAll(lambda s: s.container.asSet().size()==1 and s.container == self)
class FinalState:
def wfrFinalState1(self):
"A final state cannot have any outgoing transitions"
return self.outgoing.size()==0
class Pseudostate:
def wfrPseudostate1(self):
"An initial vertex can have at most one outgoing transition and no incoming transitions"
return implies(self.kind == PseudostateKind.pk_initial,
self.outgoing.size()<=1 and self.incoming.isEmpty())
def wftPseudostate2(self):
"History vertices can have at most one outgoing transition"
return implies(self.kind == PseudostateKind.pk_deepHistory or self.kind== PseudostateKind.pk_shallowHistory,
self.outgoing.size()<=1)
--- NEW FILE: __init__.py ---
"""
SMW The System Modeling Workbench
Copyright 2001,2002 by Ivan Porres ip...@ab...
The System Modeling Workbench is a collection of tools for
modeling software systems. From the programmer's point of view,
each supported modeling language is represented by a metamodel
module. A metamodel module contains a Python class for each model
element. These classes have the same attributes and associations
with the same name as in the metamodel of the modeling language.
Since the model elements are represented as Python classes, we
create a models by instantiating new objects and manipulating its
associations.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
"""
--- NEW FILE: makefile ---
SART.py: SARTModel.xml ../../mmgen/mmgen.py
python2 ../../mmgen/mmgen.py --uml SARTModel.xml SART.py SART 0.1 SARTtemplate.py
|
|
From: <de...@us...> - 2004-01-07 01:48:23
|
Update of /cvsroot/pymerase/smw/smw/repository/gui
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/repository/gui
Added Files:
RepositoryList.py TagHistory.py __init__.py
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: RepositoryList.py ---
from qt import *
class RepositoryList(QDialog):
def __init__(self,parent = None,name = None,modal = 0,fl = 0):
QDialog.__init__(self,parent,name,modal,fl)
self.setCaption(self.trUtf8("List of Repositories"))
self.bgroup = QVButtonGroup(self, "bgroup")
self.bgroup.setRadioButtonExclusive(1)
self.buttons = []
def setDatabases(self, dbs):
for i in dbs:
button = QRadioButton(self.bgroup, i)
button.setText(self.trUtf8(i))
button.setChecked(0)
self.connect(button, SIGNAL("clicked()"), self, SLOT("accept()"))
self.buttons.append(button)
self.bgroup.adjustSize()
self.show()
--- NEW FILE: TagHistory.py ---
#!/usr/bin/python
#
# Displays the tag/branch history as a graphical tree.
# The information is returned by aUMLApp.py/RepViewTagTree().
#
#
import operator
import re
from qt import *
try:
from qtcanvas import *
except:
pass
import dlg.jointags
import dlg.tag_information
def createTexts(canvas, texts):
all = []
for i in texts:
q = QCanvasText(QString(i), canvas)
q.show()
all.append(q)
return all
class TagHistoryItem(QCanvasRectangle):
"""One "box" in the Canvas containing one tag from the repository."""
def __init__(self, x,y,z,canvas, tagname, revision, whocheckedin, comment, datestamp):
self.children = []
self.parents = []
self.canvas = canvas
self.revision = revision
self.tagname = tagname
self.committer = whocheckedin
self.comment = comment
# Skip the subsecond part. This is a bit clumsy
datestamp = re.sub("\..+", "", datestamp)
self.datestamp = datestamp
QCanvasRectangle.__init__(self,x,y,100,100,canvas)
QCanvasRectangle.setZ(self, z)
self.childrenlines = {}
self.texts = createTexts(canvas, [tagname, str(revision), whocheckedin, datestamp])
# Calculate bounding box of texts
itemwidth = max(map(lambda x: x.boundingRect().width(), self.texts))
itemwidth += 30
itemheight = reduce(operator.add, map(lambda x: x.boundingRect().height(), self.texts))
itemheight += self.texts[0].boundingRect().height()
self.setSize(itemwidth, itemheight)
self.show()
def __update_line_points__(self, line, child):
line.setPoints(self.x() + self.width()/2,
self.y(),
child.x() + child.width()/2,
child.y() + child.height())
def update_lines(self, recurse = 1):
# Lines to children, create if not yet done
for c in self.children:
# Update all the parents lines also
if recurse:
for p in c.parents:
p.update_lines(0)
if not self.childrenlines.has_key(c):
self.childrenlines[c] = QCanvasLine(self.canvas)
self.__update_line_points__(self.childrenlines[c], c)
# same tag is colored
if self.tagname == c.tagname:
self.childrenlines[c].setPen(QPen(QColor(150, 0 , 0), 2))
self.childrenlines[c].show()
elif recurse:
self.__update_line_points__(self.childrenlines[c], c)
def update(self):
QCanvasRectangle.update(self)
x = self.x()
y = self.y()
width = self.width()
for i in self.texts:
r = i.boundingRect()
nx = x + (width - r.width())/2
ny = y + r.height()/5
i.move(nx, ny)
i.update()
i.show()
y = ny + r.height()
self.update_lines()
def drawShape(self, painter):
self.update()
QCanvasRectangle.drawShape(self,painter)
class TagHistoryCanvasView(QCanvasView):
"""Displays the Canvas of TagHistoryItems and provides the
operations on tags."""
def __init__(self, repositorymanager, canvas, parent, name):
QCanvasView.__init__(self, canvas, parent, name)
self.repositorymanager = repositorymanager
self.resize(parent.size())
self.setVScrollBarMode(QScrollView.AlwaysOn)
self.setHScrollBarMode(QScrollView.AlwaysOn)
#self.viewport().setMouseTracking(1)
self.viewport().setFocusProxy(self)
self.viewport().setFocusPolicy(QWidget.ClickFocus)
# Items chosen
self.chosen = []
self.pan = 0
def contentsMouseReleaseEvent(self, event):
if event.button() & Qt.MidButton:
self.pan = 0
# If we didn't move the mouse too much
if self.delta[0] + self.delta[1] <= 5:
choice = self.onTag(event)
if choice:
return self.showComment(choice)
def contentsMouseMoveEvent(self, event):
if not self.pan:
return
speed = 3
dx = (event.x() - self.startCoords[0])
dy = (event.y() - self.startCoords[1])
self.delta = (self.delta[0] + abs(dx), self.delta[1] + abs(dy))
dx *= speed
dy *= speed
cx = self.contentsX()
cy = self.contentsY()
canvas = self.canvas()
# We have to make sure new scroll position is ok, otherwise
# we get a "shaky" movement
if cx + dx < 0:
dx = -cx
if cx + dx + self.visibleWidth() > canvas.width():
dx = canvas.width() - cx - self.visibleWidth()
if cy + dy < 0:
dy = -cy
if cy + dy + self.visibleHeight() > canvas.height():
dy = canvas.height() - cy - self.visibleHeight()
self.setContentsPos(cx + dx, cy + dy)
# Reset the start value.
self.startCoords = (event.x() + dx, event.y() + dy)
#### Callbacks for the menu operations
### JOINING TAGS
def joinTags(self):
newbranch = None
if self.jointagsgui.revision1.isOn():
newbranch = self.t_one.tagname
elif self.jointagsgui.revision2.isOn():
newbranch = self.t_two.tagname
elif self.jointagsgui.newbranch.isOn():
newbranch = self.jointagsgui.newbranchedit.text().__str__()
if not newbranch or len(newbranch) == 0:
self.jointagsgui.reject()
return
base_rev = -1
# Try if user had proper revision
t = self.jointagsgui.base_tag_revision.text().__str__()
try:
base_rev = int(t)
except:
pass
assert(newbranch)
# BUG lacks comment
self.repositorymanager.repositoryserver.joinTags(self.t_one.revision, self.t_two.revision, newbranch, base_rev)
self.jointagsgui.reject()
def joinTagsActivateRadioButton(self):
self.jointagsgui.newbranch.setOn(1)
def joinTagsGUI(self):
self.jointagsgui = dlg.jointags.jointags(self.parent(), None, 1)
self.jointagsgui.connect(self.jointagsgui.okbutton, SIGNAL('clicked()'), self.joinTags)
self.jointagsgui.connect(self.jointagsgui.newbranchedit, SIGNAL('returnPressed()'), self.joinTags)
self.jointagsgui.connect(self.jointagsgui.newbranchedit, SIGNAL('textChanged(const QString&)'), self.joinTagsActivateRadioButton)
# Bug translate
b1 = u"Branch %s (after revision %d)" % (self.t_one.tagname, self.t_one.revision)
b2 = u"Branch %s (after revision %d)" % (self.t_two.tagname, self.t_two.revision)
self.jointagsgui.revision1.setText(str(b1))
self.jointagsgui.revision2.setText(str(b2))
self.jointagsgui.show()
#### The menu and canvas functions
def onTag(self, e):
itemlist = self.canvas().collisions(e.pos())
for i in itemlist:
if isinstance(i, QCanvasRectangle):
return i
return None
def showMenu(self, e):
"""Show a menu displaying the different actions that can
be done to the tags."""
choice = self.onTag(e)
# The tag under the mouse is added if it isn't
# active yet. This just feels intuitive to the user, I hope.
add_extra = 0
if choice:
if choice not in self.chosen:
if len(self.chosen) < 3:
self.chosen.append(choice)
add_extra = 1
else:
# Rearrange so the tag under the mouse is the first one
# Again, hopefully feels more intuitive
# Note that we don't set add_extra, because this tag
# was already chosen by the user.
self.chosen.remove(choice)
self.chosen.append(choice)
# Reverse so we have latest-first
self.chosen.reverse()
taglen = len(self.chosen)
if taglen > 0:
self.t_one = t_one = self.chosen[0]
if taglen > 1:
self.t_two = t_two = self.chosen[1]
if taglen > 2:
self.t_three = t_three = self.chosen[2]
self.chosen.reverse()
if add_extra:
self.chosen.pop()
self.menu = QPopupMenu(self, "Tag Operations")
# Add different menus depending on how many
# tags are chosen
if taglen > 0:
id_update = self.menu.insertItem("N/A Update model to revision %d" % t_one.revision )
id_diff_two_model = self.menu.insertItem("N/A Show difference between model and revision %d" % t_one.revision )
else:
id_update = self.menu.insertItem("N/A Update model to a revision")
id_diff_two_model = self.menu.insertItem("N/A Show difference between model and a revision")
self.menu.setItemEnabled(id_update, 0)
self.menu.setItemEnabled(id_diff_two_model, 0)
if taglen > 1:
id_diff_two = self.menu.insertItem("N/A Show difference between revisions %d and %d" % (t_one.revision, t_two.revision ))
id_jointags = self.menu.insertItem("Join revisions %d and %d..." % (t_one.revision, t_two.revision), self.joinTagsGUI)
id_diff_three_model = self.menu.insertItem("N/A Show three-way difference between revisions %d, %d and model" % (t_one.revision, t_two.revision))
else:
id_diff_two = self.menu.insertItem("N/A Show difference between two revisions")
id_jointags = self.menu.insertItem("Join two revisions")
id_diff_three_model = self.menu.insertItem("N/A Show three-way difference between two revisions and model")
self.menu.setItemEnabled(id_diff_two, 0)
self.menu.setItemEnabled(id_diff_three_model, 0)
self.menu.setItemEnabled(id_jointags, 0)
if taglen > 2:
id_diff_three = self.menu.insertItem("N/A Show three-way difference between revisions %d, %d and %d" % (t_one.revision, t_two.revision, t_three.revision ))
else:
id_diff_three = self.menu.insertItem("N/A Show three-way difference between three revisions")
self.menu.setItemEnabled(id_diff_three, 0)
# Show at mouse position
x = e.pos().x() - self.contentsX()
y = e.pos().y() - self.contentsY()
self.menu.popup(self.mapToGlobal(QPoint(x, y)))
def showComment(self, item):
"""Shows new window with more information about the tag."""
ti = dlg.tag_information.TagInformation(self, None, 0)
ti.revision.setText(str(item.revision))
ti.branchname.setText(str(item.tagname))
ti.committer.setText(str(item.committer))
ti.date.setText(str(item.datestamp))
ti.comment.setText(str(item.comment))
# Make shorter, according to comment height
size = ti.comment.size()
h = ti.comment.heightForWidth(size.width()) + ti.comment.horizontalScrollBar().height() + 5 # The +5 is for letter below baseline
ti.comment.resize(size.width(), h)
ti.show()
def contentsMousePressEvent(self, e):
"""Takes care of selecting / unselecting tags."""
# Right button shows menu of options
if e.button() == Qt.RightButton:
return self.showMenu(e)
# Show comment of a tag
# BUG Windows/Mac users.
if e.button() == Qt.MidButton:
# PAN THE VIEW INSTEAD
self.startCoords = (e.x(), e.y())
self.delta = (0,0)
self.pan = 1
return
# Left mouse button, select/deselect tags
choice = self.onTag(e)
if not choice:
return None
if choice in self.chosen:
self.chosen.remove(choice)
color = QColor(0,0,0)
else:
# No more than 3 chosen items
if len(self.chosen) >= 3:
return None
self.chosen.append(choice)
color = QColor(100, 100, 255)
choice.setPen(QPen(color))
self.canvas().update()
return None
class TagHistory(QDialog):
"""Main class which displays the window with the given tag history information.
Builds up a tree and puts the tags into good places.
Currently, the placing algorithm doesn't work nicely for joined tags.
There also is a small glitch when narrow tags are the only children(?)."""
def __init__(self, repositorymanager, history, taginfo, parent = None,name = None,modal = 0,fl = 0):
QDialog.__init__(self,parent,name,modal,fl)
self.repositorymanager = repositorymanager
if name == None:
self.setName('taghistory')
# maximum height of a certain tag level
self.levels = {}
self.dist_between_generations = 30
self.resize(596,480)
self.setCaption(self.tr("Complete Tag History"))
self.canvas = QCanvas()
self.canvas.setDoubleBuffering(0)
self.cv = TagHistoryCanvasView(repositorymanager, self.canvas, self, "TagHistoryView")
self.historyhash = history
self.taginfo = taginfo
self.all_items = {}
(width, height) = self.createTopology()
self.canvas.resize(width, height)
self.update()
self.canvas.setAllChanged()
self.canvas.update()
self.cv.show()
def resizeEvent(self, QResizeEvent):
"""Resizes the QCanvasView self.cv along with the
dialog resizing."""
self.cv.resize(self.size())
def __create_item__(self, revision, historystart):
if not self.all_items.has_key(revision):
datestamp = historystart[0]
uuid = historystart[1]
whocheckedin = historystart[2]
comment = historystart[3]
self.all_items[revision] = TagHistoryItem(0, 0, 0, self.canvas, self.taginfo[uuid], revision, whocheckedin, comment, datestamp)
return self.all_items[revision]
##
## ALGORITHM FOR THE PLACEMENT OF TAGHISTORYITEMS
##
##* Get list of tag revisions and their children
## * hash children[parentrevision] = list-of-children
## * hash parent[childrevision] = list-of-parents
##* Initialize
## * branches = []
## * location[revision] = {}
##Then we do a topological walktrough of the tags
##* Initialize
## * frontier = [ 1 ], contains the list of tags which we want to
## check
##* While we can take the first tag (basically, any tag) from frontier as
## our current tag
## * If current is already in location, continue with next tag
## * Get list of current's parents
## * If all parents are already in location
## * Create a new item, based on current
## * GFX: y position is the lowest parent's y position minus the distance-between-revisions
## * Add to location
## * If current has the same name as any of its parents,
## and that parent has not continued its' branch,
## => continue on that branch
## * GXF: x position is the new branch's x position
## * Otherwise, create a new branch
## * Allocate x position to the new branch
## * Add all current's children to frontier
##
def createTopology(self):
# Revision one has no parents
parents = { 1: []}
children = {}
# Create the children and parents hashes
for tagrev in self.historyhash.keys():
children[tagrev] = self.historyhash[tagrev][4:]
for child in children[tagrev]:
if not parents.has_key(child):
parents[child] = []
parents[child].append(tagrev)
branches = []
location = {}
frontier = [ 1 ]
while len(frontier) > 0:
current = frontier.pop(0)
if location.has_key(current):
continue
all_parents_exist = 1
for p in parents[current]:
if not location.has_key(p):
all_parents_exist = 0
break
if not all_parents_exist:
continue
item = self.__create_item__(current, self.historyhash[current])
# The 0 is the initial placement of revision 1
# Everything will be translated up anyway, so there's
# nothing to worry about
y = reduce(min, map(lambda p: location[p].y(), parents[current]), 0)
# Move child slightly lower then lowest parent
y = y - item.height() * 1.5
location[current] = item
# If there are graphical mistakes anywhere, it's here...
has_same_name = 0
my_parent = None
for p in parents[current]:
item.parents.append(location[p])
if location[p].tagname == item.tagname:
my_parent = location[p]
# Has this parent continued its branch?
for c in children[p]:
citem = self.__create_item__(c, self.historyhash[c])
if citem.tagname == item.tagname:
has_same_name += 1
if has_same_name != 1:
# Create new branch
if current == 1:
assert(my_parent == None)
x = 0 # Initial placement of revision 1
else:
x = branches[-1].x() + item.width()*1.3 # Distance between branches
item.move(x, y)
branches.append(item)
else:
# Continue on old branch
midx = my_parent.x() + my_parent.width() / 2
item.move(midx - item.width() / 2, y)
for child in children[current]:
citem = self.__create_item__(child, self.historyhash[child])
item.children.append(citem)
frontier.append(child)
# TRANSLATE
# Since revision 1 started at (0,0), all items are
# beyond the canvas
minx = min(map(lambda item: item.x(), location.values()))
miny = min(map(lambda item: item.y(), location.values()))
# The +50 makes the tags go slight away from the topleft edge
EDGE = 50
map(lambda item: item.moveBy(-minx + EDGE, -miny + EDGE), location.values())
map(lambda item: item.update(), location.values())
# Simplistic way to calculate width and height
width = max(map(lambda item: item.x() + item.width(), location.values()))
height = max(map(lambda item: item.y() + item.height(), location.values()))
return (width + EDGE, height + EDGE)
--- NEW FILE: __init__.py ---
|
|
From: <de...@us...> - 2004-01-07 01:48:22
|
Update of /cvsroot/pymerase/smw/smw/repository/db/unittest
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/repository/db/unittest
Added Files:
__init__.py testCreateDatabase.py
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: __init__.py ---
--- NEW FILE: testCreateDatabase.py ---
#
# Tests creating a UML 1.4 database. Destroys it afterwards.
# This is a very simple test, and basically it is already tested
# by several other tests implicitly.
#
import os
import sys
try:
user = os.environ["USER"]
except:
user = "noname"
if user != "maalanen":
print "Can't test createdbtest.py"
sys.exit(0)
from smw.repository.db.dbback import *
delete_database("test", "maalanen", "merknitz")
create_database("test", "smw.metamodel.UML14", "maalanen", "merknitz")
|
|
From: <de...@us...> - 2004-01-07 01:48:22
|
Update of /cvsroot/pymerase/smw/smw/modeler/plugins
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/modeler/plugins
Added Files:
__init__.py repoPlugin.py transPlugin.py
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: __init__.py ---
--- NEW FILE: repoPlugin.py ---
import qt
import sys
import copy
import smw.repository.release
from smw.ipmanager import IPManager
IPManager().registerIPModule(smw.repository.release)
from smw.Project import getProjectInstance
from smw.repository.gui.dlg import repmain
from smw.repository.gui.RepositoryList import RepositoryList
from smw.repository.gui.dlg.create_new_repo import CreateNewRepo
from smw.metamodel.MetaMM import getMetamodelByName, getElementsOfModel, modelcopy
from smw import io
from xmlrpclib import ServerProxy
from os import environ
from smw.repository.gui.TagHistory import *
from smw.repository.gui.dlg.commentedit import *
from smw import exceptions
from smw import log
from smw.modeler import iconcache
from smw.repository.gfx_resolver import GfxResolver
from smw import SignalHandling
from smw import Configuration
import re
therepmanager = None
class RepositoryManagerPlugin:
def __init__(self,modelerApp):
global therepmanager
therepmanager = self
self.modelerApp=modelerApp
self.config=Configuration.Configuration()
self.repolog = log.getLogger("Repository")
self.repositoryserver = None
i = {}
i["user"] = environ.get("USER", "anonymous")
i["branch"] = "Main"
i["revision"] = 0
i["server"] = "localhost"
i["repository"] = "repository"
i["port"] = str(self.config.getParameter("smw_server_default_port"))
i["sharedelement"] = ""
self.info = i
i["password"] = ""
# Use these keys if given
self.only_module = None
self.favour_rev_instead_of_branchname = 0
#
# This contains the unmodified model that we have received
# from the repository. It is needed for proper client-side
# diff3/patch3, as well as checkin-by-modeldifference.
#
self.checked_out_model = None
SignalHandling.registerReceiver("savedModel", self.slotSavedModel)
def __del__(self):
SignalHandling.unregisterReceiver("savedModel", self.slotSavedModel)
def slotSavedModel(self, signal, privateparams, params):
h = params["toupdate"]
if not h.has_key("revision"):
# No versioned model, what to do?
return
if h.has_key("branch"):
self.info["branch"] = h["branch"]
self.info["revision"] = h["revision"]
self.updateGUI()
h = self.__get_vars__()
self.modelerApp.project.fileName = io.create_url(h)
self.modelerApp.updateCaption()
self.comment = ""
def repositoryManagement(self):
self.cRep = repmain.repmain(self.modelerApp, "Repository Main Window", 0)
self.cRep.connect(self.cRep.checkin, qt.SIGNAL('clicked()'), self.RepCheckin)
self.cRep.connect(self.cRep.checkout, qt.SIGNAL('clicked()'), self.RepCheckout)
self.cRep.connect(self.cRep.update, qt.SIGNAL('clicked()'), self.RepUpdate)
self.cRep.connect(self.cRep.viewtagtree, qt.SIGNAL('clicked()'), self.RepViewTagTree)
self.cRep.connect(self.cRep.editcomment, qt.SIGNAL('clicked()'), self.editComment)
self.cRep.connect(self.cRep.addmodule, qt.SIGNAL('clicked()'), self.RepAddModule)
self.cRep.connect(self.cRep.list_repositories, qt.SIGNAL('clicked()'), self.RepGetListOfRepositories)
self.cRep.connect(self.cRep.create_new_repository, qt.SIGNAL('clicked()'), self.RepCreateNewRepository)
self.updateGUI()
self.cRep.show()
def updateGUI(self, h = None):
if h == None:
h = self.info
self.cRep.user.setText(h["user"])
self.cRep.tag.setText(h["branch"])
repotext = str(h["revision"])
if h["revision"] == 0: repotext = "Latest"
self.cRep.revision.setText(repotext)
self.cRep.server.setText(h["server"])
self.cRep.port.setText(h["port"])
self.cRep.repository.setText(h["repository"])
self.cRep.moduleid.setText(h.get("sharedelement", ""))
self.cRep.password.setText(h["password"])
if self.favour_rev_instead_of_branchname:
self.cRep.revision_radio_button.setChecked(1)
else:
self.cRep.branch_radio_button.setChecked(1)
self.comment = ""
setme = 1
if h != self.info:
setme = 0
self.cRep.update.disconnect(self.cRep.update, qt.SIGNAL('clicked()'), self.RepUpdate)
self.cRep.connect(self.cRep.update, qt.SIGNAL('clicked()'), self.cRep, SLOT("accept()"))
self.cRep.checkin.setEnabled(setme)
self.cRep.checkout.setEnabled(setme)
self.cRep.viewtagtree.setEnabled(setme)
self.cRep.editcomment.setEnabled(setme)
self.cRep.addmodule.setEnabled(setme)
self.cRep.list_repositories.setEnabled(setme)
self.cRep.create_new_repository.setEnabled(setme)
#self.cRep..setEnabled(setme)
#self.cRep..setEnabled(setme)
def editComment(self):
cw = CommentEdit(self.cRep, None, 1)
cw.edit.setText(self.comment)
cw.exec_loop()
if cw.result() == qt.QDialog.Accepted:
self.comment = str(cw.edit.text())
def RepGetServer(self, authenticate = 1):
# BUG: this should be cached if possible
self.repositoryserver = None
h = self.__get_vars__()
url = io.create_url(h)
self.repolog.debug("Contacting repository at url %s" % url)
try:
self.repositoryserver = io.connect_to_server(url, authenticate)
except:
# Connection failed
print "Error %s:%s" % (sys.exc_type, sys.exc_value)
self.repositoryserver = None
qt.QMessageBox.critical(self.cRep,
"Communication Error",
"%s. Please check with your server administrator." % sys.exc_value)
raise
def __get_vars__(self, save = 1):
"""Reads the GUI variables and returns them in a hash"""
port = str(self.cRep.port.text())
server = str(self.cRep.server.text())
repository = str(self.cRep.repository.text())
tag = str(self.cRep.tag.text())
revision = str(self.cRep.revision.text())
rev = 0
# Check whether branch or revision was active
if not self.cRep.revision.isEnabled():
revision = 0
else:
tag = ""
try:
rev = int(revision)
except:
# BUG maybe we should show error dialog and say that
# only numbers are allowed?
pass
user = str(self.cRep.user.text())
password = str(self.cRep.password.text())
module_uuid = str(self.cRep.moduleid.text())
h = {"branch": tag,
"port": port,
"repository": repository,
"revision": rev,
"server": server,
"password": password,
"user": user,
"comment": self.comment }
if len(module_uuid) > 0:
h["sharedelement"] = module_uuid
if not self.cRep.updatetag.isChecked():
newtag = str(self.cRep.newtag.text())
# BUG should display error window
assert(newtag != "")
h["newtag"] = newtag
if save:
# Save the variables so they are not reset
# across frame open/close
self.info = copy.copy(h)
return h
def RepUpdate(self):
assert(self.checked_out_model != None)
h = self.__get_vars__()
# We are not interested in the addmodule part when updating
if h.has_key("sharedelement"):
del h["sharedelement"]
url = io.create_url(h)
m = self.modelerApp.project.getRoot()
resolution = io.updateModel(url, m, self.checked_out_model)
# No conflicts
if resolution[0] == 0:
(_, m, new_checked_out_model, new_revision) = resolution
# Conflicts
elif resolution[0] == 1:
(_, currentmodel, new_checked_out_model, new_revision, change_this_md, this_md_already_applied) = resolution
g = GfxResolver(self.cRep, currentmodel, change_this_md, this_md_already_applied)
g.exec_loop()
if g.result() != qt.QDialog.Accepted:
self.cRep.reject()
new_model = g.getNewModel()
else:
assert(0)
self.modelerApp.project.setRoot(m)
self.checked_out_model = new_checked_out_model
self.info["revision"] = str(new_revision)
h["revision"] = self.info["revision"]
self.modelerApp.project.fileName = io.create_url(h)
self.modelerApp.updateCaption()
self.cRep.reject()
# BUG refresh display
def RepCheckin(self):
h = self.__get_vars__()
# We are not interested in the addmodule part when saving
if h.has_key("sharedelement"):
del h["sharedelement"]
url = io.create_url(h)
try:
getProjectInstance().saveModel(url, h)
except exceptions.NoSuchTag:
pass
else:
self.repolog.debug("Checking in branch " + str(self.info["branch"]) + " at revision " + str(self.info["revision"]))
self.favour_rev_instead_of_branchname = 1
self.cRep.reject()
def RepCheckout(self):
h = self.__get_vars__()
if h.has_key("sharedelement"):
del h["sharedelement"]
url = io.create_url(h)
self.repolog.debug("Checking out tag " + str(self.info["branch"]) + " at revision " + str(self.info["revision"]))
try:
self.modelerApp.openProject(url, h)
except Exception:
self.favour_rev_instead_of_branchname = 0
self.repolog.exception("Repository checkout error")
qt.QMessageBox.warning(self.cRep,
"Repository Checkout Error",
"Couldn't checkout from the repository.\n")
else:
# Success in checking out
# Take a copy for diff3/patch
self.checked_out_model = modelcopy(self.modelerApp.project.getRoot())
self.info["branch"] = h["branch"]
self.info["revision"] = h["revision"]
u = io.create_url(h)
self.modelerApp.project.fileName = io.getDisplayUrl(u)
self.modelerApp.updateCaption()
self.favour_rev_instead_of_branchname = 1
self.cRep.reject()
def RepViewTagTree(self):
self.RepGetServer()
a = self.repositoryserver.getWholeHistory()
history = a[0]
taginfo = a[1]
rev = 0
hash = {}
for i in history:
if type(i) == list:
hash[rev] = i
else:
rev = i
taghash = {}
for i in taginfo: taghash[i[1]] = i[0]
self.repolog.debug(hash)
self.repolog.debug(taghash)
self.taghistory = TagHistory(self, hash, taghash, self.cRep, "Complete Tag History", 0)
self.taghistory.show()
def RepAddModule(self):
self.repolog.debug("AddModule()")
h = self.__get_vars__(0)
url = io.create_url(h)
if not h.has_key("sharedelement"):
qt.QMessageBox.warning(self.cRep,
"Invalid Module ID",
"You must supply a module id. It is a string corresponding to the XMI id of the element you want to import.")
return
self.repolog.debug("Adding module from URL %s" % url)
# BUG we might not have an "ownedElement" composition
myset = self.modelerApp.diagramEditor.editorTab.currentPage().focus.ownedElement
# This just places it in the root element
# myset = self.modelerApp.project.getRoot().ownedElement
io.loadModule(url, myset)
# BUG refresh display
self.cRep.reject()
def RepGetListOfRepositories(self):
self.RepGetServer(0)
databases = self.repositoryserver.getRepositories(self.info["user"], self.info["password"])
databases.sort()
r = RepositoryList(self.modelerApp, None, 1)
r.setDatabases(databases)
r.exec_loop()
if r.result() == qt.QDialog.Accepted:
print "accepted"
button = r.bgroup.selected()
if not button:
return
print "set button"
self.cRep.repository.setText(button.text())
def RepCreateNewRepository(self):
r = CreateNewRepo(self.modelerApp, None, 1)
r.exec_loop()
if r.result() == qt.QDialog.Accepted:
self.RepGetServer(0)
self.repositoryserver.createRepository(str(r.repository_name.text()), str(r.metamodel.text()), self.info["user"], self.info["password"])
# lame hack
__my_element__ = None
def updateModule(self):
global therepmanager
print "should update module"
element = __my_element__
url = element.subject[0].getModule()
h = io.get_url_keys_and_values(url)
print "url ", url
therepmanager.repositoryManagement()
therepmanager.updateGUI(h)
therepmanager.cRep.exec_loop()
if therepmanager.cRep.result() == qt.QDialog.Accepted:
h = therepmanager.__get_vars__(0)
url = io.create_url(h)
# No need to catch the new element,
# since it isn't the top-level Model
(_, _, _, newrevision) = io.updateModel(url, element.subject[0], 0)
h["revision"] = newrevision
element.subject[0].setModule(io.getDisplayUrl(io.create_url(h)))
def updateMenu(signame, None, data):
element = data["element"]
contextMenu = data["menu"]
global __my_element__
__my_element__ = element
# "Update module" entry
if element and element.subject[0].isModule():
m = element.subject[0].getModule()
contextMenu.insertSeparator()
# '&' chars are removed by qt, so make them &&
m = re.sub("&", "&&", m)
id = contextMenu.insertItem(
qt.QIconSet(iconcache.getIcon('repository')),
"Update module (url is %s)" % m, updateModule)
# The editor calls the register method to allow the module to
# install new actions, etc...
#
# register should instanciate the actual plugin and return it to
# the editor
def register(modelerApp):
# preferences
repopref=[
Configuration.StringParameter("module_color",
"RGB color for a module",
(255,70,70)),
Configuration.StringParameter("module_color_light",
"light RGB color for a module",
(255,130,130))
]
config=Configuration.Configuration()
for p in repopref:
config.registerParameter(p)
# create the plugin object
manager=RepositoryManagerPlugin(modelerApp)
# register a new action 'repositoryManagment'
# with a fancy name and icon.
# when the user activates the action, manager.repositoryManagement
# will be called
# the action belongs to the group 'modeler', since it is a global action
# other groups are 'project' that is only active when a project is loaded
# and 'selection' that is only active when some items are selected
modelerApp.actions.registerAction(
"repositoryManagement","Repository Management...",
qt.QIconSet(iconcache.getIcon("repository")),
0,manager,manager.repositoryManagement,"modeler")
# Tell the application to place the icon and menu option just after the
# openProject action. (The editor will try to do its best, but maybe the
# place is already taken by another plugin)
modelerApp.actions["repositoryManagement"].pleaseShowAfter(
modelerApp.actions["openProject"])
modelerApp.actions["repositoryManagement"].setEnabled(1)
SignalHandling.registerReceiver("MenuPopup", updateMenu, None)
return manager
--- NEW FILE: transPlugin.py ---
import qt
from smw.metamodel.UML14 import *
from smw.modeler.TransEditor import *
from smw.modeler.DialogEditor import *
from smw.modeler.DiagramEditor import *
from smw.transform.editormtr import *
from smw import Configuration
import string
import sys
import traceback
import copy
import codecs
class TEditor:
"""
Transformation Editor
"""
def __init__(self,modelerApp):
self.modelerApp=modelerApp
self.editor = 0
def teditor(self):
if not self.editor:
self.editor = TransformationDlg(self.modelerApp, "Transformation Main Window", 0)
self.editor.show()
def updateMenu(signame, None, data):
element = data["element"]
contextMenu = data["menu"]
global __my_element__
__my_element__ = element
# "Update module" entry
if element and element.subject[0].isModule():
m = element.subject[0].getModule()
contextMenu.insertSeparator()
# '&' chars are removed by qt, so make them &&
m = re.sub("&", "&&", m)
id = contextMenu.insertItem(
qt.QIconSet(iconcache.getIcon('repository')),
"Update module (url is %s)" % m, updateModule)
# The editor calls the register method to allow the module to
# install new actions, etc...
#
# register should instanciate the actual plugin and return it to
# the editor
def register(modelerApp):
# create the plugin object
t = TEditor(modelerApp)
modelerApp.actions.registerAction(
"trans","Transformation...",
qt.QIconSet(iconcache.getIcon("pluginManager")),
0,t,t.teditor,"modeler")
# Tell the application to place the icon and menu option just after the
# pluginManager action. (The editor will try to do its best, but maybe the
# place is already taken by another plugin)
modelerApp.actions["trans"].pleaseShowAfter(
modelerApp.actions["pluginManager"])
modelerApp.actions["trans"].setEnabled(1)
return t
|
|
From: <de...@us...> - 2004-01-07 01:48:22
|
Update of /cvsroot/pymerase/smw/smw/profiles/UML14/plugins
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/profiles/UML14/plugins
Added Files:
__init__.py mmgenPlugin.py vUML.py
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: __init__.py ---
--- NEW FILE: mmgenPlugin.py ---
import qt
from smw.modeler import iconcache
class MMGenPlugin:
def __init__(self,modelerApp):
self.modelerApp=modelerApp
def doIt(self):
from smw.mmgen import mmgen
if self.modelerApp.project.profile.name!="UML14":
qt.QMessageBox.critical(self.modelerApp,"Invalid Profile",
"This plugin only works with the standard UML 1.4 profile.")
return
dlg=mmgen.GeneratorGUI()
dlg.SourceFile.setText("Current model in editor")
dlg.SelectSource_3.setEnabled(0)
dlg.SourceFile.setEnabled(0)
dlg.UMLFormat.setChecked(1)
dlg.FileFormat_3.setEnabled(0)
dlg.UMLVersion.setCurrentText(self.modelerApp.project.profile.name)
dlg.model=self.modelerApp.project.getRoot()
dlg.exec_loop()
def register(modelerApp):
mmgen=MMGenPlugin(modelerApp)
modelerApp.actions.registerAction(
"mmgenTool","Metamodel Generation Tool...",
qt.QIconSet(iconcache.getIcon("pluginManager")),
0,mmgen,mmgen.doIt,"project")
# Tell the application to place the icon and menu option just after the
# openProject action. (The editor will try to do its best, but maybe the
# place is already taken by another plugin)
modelerApp.actions["mmgenTool"].pleaseShowAfter(
modelerApp.actions["pluginManager"])
return mmgen
--- NEW FILE: vUML.py ---
import qt
from smw.modeler import iconcache
class vUMLPlugin:
def __init__(self,modelerApp):
self.modelerApp=modelerApp
def doIt(self):
if self.modelerApp.project.profile.name!="UML14":
qt.QMessageBox.critical(self.modelerApp,"Invalid Profile",
"This plugin only works with the standard UML 1.4 profile.")
return
def register(modelerApp):
mmgen=vUMLPlugin(modelerApp)
modelerApp.actions.registerAction(
"vUMLTool","vUML Tool...",
qt.QIconSet(iconcache.getIcon("pluginManager")),
0,mmgen,mmgen.doIt,"project")
# Tell the application to place the icon and menu option just after the
# openProject action. (The editor will try to do its best, but maybe the
# place is already taken by another plugin)
modelerApp.actions["vUMLTool"].pleaseShowAfter(
modelerApp.actions["pluginManager"])
return mmgen
|
|
From: <de...@us...> - 2004-01-07 01:48:22
|
Update of /cvsroot/pymerase/smw/smw/profiles/UML14 In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/profiles/UML14 Added Files: __init__.py Log Message: Imported version of SMW downloaded on 2003 Apr 14 --- NEW FILE: __init__.py --- |
|
From: <de...@us...> - 2004-01-07 01:48:22
|
Update of /cvsroot/pymerase/smw/smw/modeler/unittest
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/modeler/unittest
Added Files:
Cap.smt __init__.py model.smw test.iml testCap.py
testLoadModelWithPresentations.py testTrans.py testaUMLApp.py
transformation.smt
Log Message:
Imported version of SMW downloaded on 2003 Apr 14
--- NEW FILE: Cap.smt ---
(ismw.modeler.TransEditor
Transformation
p1
(dp2
S'edited'
p3
I0
sS'log'
p4
(ismw.log
LogAdapter
(dp5
S'logger'
p6
(ismw.log
Logger
(dp7
S'observers'
p8
(lsS'channels'
p9
(dsS'lastTime'
p10
S'Thu, 19 Dec 2002 13:31'
sbsS'channel'
p11
S'Transformation'
p12
sbsS'parameters'
p13
(dsS'execRes'
p14
(lp15
I0
asS'doc'
p16
S''
sS'counter'
p17
I0
sS'namespace'
p18
(dp19
S'self'
p20
g1
sS'name'
p21
S'unnamed'
p22
ssg21
S'Cap'
sS'newE'
p23
I0
sS'guard'
p24
S'1'
sS'stick'
p25
I1
sS'ruleSet'
p26
(lp27
(ismw.modeler.TransEditor
Rule
p28
(dp29
S'body'
p30
S'e.name=string.capitalize(e.name)'
sg3
I0
sg24
S'e.name[0] not in string.ascii_uppercase'
sS'parent'
p31
g1
sg21
S'New Rule'
sS'para'
p32
S'e:Classifier'
sg16
S'This is the documentation of a Rule'
sS'__name__'
p33
S'rule'
p34
sbasS'metamodel'
p35
Nsg33
S'transformation'
p36
sS'model'
p37
NsS'once'
p38
I1
sS'consumer'
p39
NsS'common'
p40
S''
sb.
--- NEW FILE: __init__.py ---
--- NEW FILE: model.smw ---
SMW_MODEL
METAMODEL smw.metamodel.UML14
PROFILE UML14
(ismw.metamodel.UML14
Model
p1
(dp2
S'isAbstract'
p3
I0
sS'isSpecification'
p4
I0
sS'__uniqueID__'
p5
S'DCE:3D725E52-0A9E-11D7-8A7C-0004761E9A69'
p6
sS'modulestring'
p7
[...3447 lines suppressed...]
(ismw.metamodel.MetaMM
MMAssociationEnd
p650
(dp651
g11
(I3
g50
I0
g51
I0
I0
tp652
sg15
g47
sg16
g1
sg17
(lp653
g164
asbsb.
--- NEW FILE: test.iml ---
SMW_MODEL
METAMODEL x
PROFILE None
(ismw.metamodel.UML14
Model
p1
(dp2
S'isAbstract'
p3
I0
sS'isSpecification'
p4
I0
sS'__uniqueID__'
p5
S'viyaoijdwtsscobh'
p6
sS'isRoot'
p7
[...1518 lines suppressed...]
asbsg28
(ismw.metamodel.MetaMM
MMAssociationEnd
p329
(dp330
g16
(I3
g31
I0
g32
I0
tp331
sg20
g28
sg21
g1
sg22
(lp332
g38
asbsb.
--- NEW FILE: testCap.py ---
import time
import unittest
import sys
import string
from smw.modeler import modelerApp
from smw.modeler.TransEditor import *
smw=modelerApp.modelerApp()
smw.main(loop=0,args=["--profile","UML14"])
smw.openProject('model.smw')
smw.processEvents()
tdlg=TransformationDlg(smw)
tdlg.show()
##Tests that the transformation is changed and the different fields
##are uppdated
smw.processEvents()
p = tdlg.TEL.editor.subEditors[0].currentTrans
counter = tdlg.TEL.editor.subEditors[0].runTrans()
assert(str(tdlg.TEL.editor.subEditors[1].NameLineEdit.text())==p.name)
assert(str(tdlg.TEL.editor.subEditors[1].GuardLineEdit.text())==p.guard)
assert(str(tdlg.TEL.editor.subEditors[1].ComTextEdit.text())==p.common)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
NLineEdit.text())==p.ruleSet[0].name)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
PLineEdit.text())==p.ruleSet[0].para)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
GLineEdit.text())==p.ruleSet[0].guard)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
BTextEdit.text())==p.ruleSet[0].body)
smw.processEvents()
tdlg.TEL.itable.setCurrentCell(1,0)
c = tdlg.TEL.editor.subEditors[0].currentTrans
assert(c==tdlg.TEL.list[1])
assert(c!=p)
assert(str(tdlg.TEL.editor.subEditors[1].NameLineEdit.text())!=p.name)
##Can't be tested since they both have the same values
##assert(str(tdlg.TEL.editor.subEditors[1].GuardLineEdit.text())!=p.guard)
##assert(str(tdlg.TEL.editor.subEditors[1].ComTextEdit.text())!=p.common)
##assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
## NLineEdit.text())!=p.ruleSet[0].name)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
PLineEdit.text())!=p.ruleSet[0].para)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
GLineEdit.text())!=p.ruleSet[0].guard)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
BTextEdit.text())!=p.ruleSet[0].body)
assert(str(tdlg.TEL.editor.subEditors[1].NameLineEdit.text())==c.name)
assert(str(tdlg.TEL.editor.subEditors[1].GuardLineEdit.text())==c.guard)
assert(str(tdlg.TEL.editor.subEditors[1].ComTextEdit.text())==c.common)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
NLineEdit.text())==c.ruleSet[0].name)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
PLineEdit.text())==c.ruleSet[0].para)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
GLineEdit.text())==c.ruleSet[0].guard)
assert(str(tdlg.TEL.editor.subEditors[3].editor.subEditors[0].\
BTextEdit.text())==c.ruleSet[0].body)
smw.processEvents()
##
##Tests that Cap transformation transformed every Classifier name
for e in smw.project.getRoot().getAllParts():
if e.oclIsKindOf(Classifier):
assert(e.name[0] in string.ascii_uppercase)
smw.processEvents()
##
tdlg.close()
--- NEW FILE: testLoadModelWithPresentations.py ---
from smw import io
model=io.loadModel("test.iml")
assert(model)
io.saveModel("ModelWithPresentations2.iml",model)
--- NEW FILE: testTrans.py ---
import time
import unittest
import sys
from smw.modeler import modelerApp
from smw.modeler.TransEditor import *
smw=modelerApp.modelerApp()
smw.main(loop=0,args=["--profile","UML14"])
smw.openProject('model.smw')
smw.processEvents()
tdlg=TransformationDlg(smw)
tdlg.show()
##TEST COVERAGE AND REPETITION
smw.processEvents()
tdlg.TEL.itable.setCurrentCell(1,0)
counter = tdlg.TEL.editor.subEditors[0].runTrans()
c,a=0,0
for e in smw.project.getRoot().getAllParts():
if e.oclIsKindOf(Classifier):
c = c+1
if e.oclIsKindOf(Attribute):
a=a+1
val = (c*a)*2
assert(counter==val)
smw.processEvents()
counter = tdlg.TEL.editor.subEditors[0].runTrans()
c,a=0,0
for e in smw.project.getRoot().getAllParts():
if e.oclIsKindOf(Classifier):
c = c+1
if e.oclIsKindOf(Attribute):
a=a+1
val = (c*a)*2
assert(counter==val)
smw.processEvents()
counter = tdlg.TEL.editor.subEditors[0].runTrans()
c,a=0,0
for e in smw.project.getRoot().getAllParts():
if e.oclIsKindOf(Classifier):
c = c+1
if e.oclIsKindOf(Attribute):
a=a+1
val = (c*a)*2
assert(counter==val)
smw.processEvents()
##
tdlg.close()
--- NEW FILE: testaUMLApp.py ---
import unittest
import sys
from smw.modeler import modelerApp
smw=modelerApp.modelerApp()
smw.main(loop=0,args=["--profile","UML14"])
# test About dialog
ad=smw.about()
ad.close()
smw.closeProject()
ad=smw.about()
ad.close()
assert(smw.project==None)
smw.processEvents()
smw.newProject(useDefaultProfile=1)
ad=smw.about()
ad.close()
assert(not smw.project.history.canUndo())
assert(not smw.project.history.canRedo())
smw.processEvents()
smw.closeProject()
smw.processEvents()
smw.newProject(useDefaultProfile=1)
smw.processEvents()
smw.saveProjectAs('empty.smw')
smw.processEvents()
smw.saveProject()
smw.processEvents()
smw.closeProject()
smw.processEvents()
smw.openProject('empty.smw')
smw.processEvents()
assert(not smw.project.history.canUndo())
assert(not smw.project.history.canRedo())
smw.openProject('empty.smw')
smw.processEvents()
# test undo and redo (with empty history)
for i in range(3):
smw.undo()
for i in range(3):
smw.redo()
smw.quit()
--- NEW FILE: transformation.smt ---
(ismw.modeler.TransEditor
Transformation
p1
(dp2
S'log'
p3
(ismw.log
LogAdapter
(dp4
S'logger'
p5
(ismw.log
Logger
p6
(dp7
S'observers'
p8
(lsS'channels'
p9
(dsS'lastTime'
p10
S'Thu, 19 Dec 2002 16:54'
sbsS'channel'
p11
S'Transformation'
p12
sbsS'edited'
p13
I0
sS'name'
p14
S'transformation'
sS'parameters'
p15
(dsS'once'
p16
I1
sS'execRes'
p17
(lp18
I0
asS'doc'
p19
S''
sS'counter'
p20
I0
sS'namespace'
p21
(dp22
S'self'
p23
g1
sg14
S'unnamed'
p24
ssS'newE'
p25
I0
sS'guard'
p26
S'1'
sS'common'
p27
S''
sS'metamodel'
p28
NsS'__name__'
p29
S'transformation'
p30
sS'model'
p31
NsS'stick'
p32
I1
sS'consumer'
p33
NsS'ruleSet'
p34
(lp35
(ismw.modeler.TransEditor
Rule
p36
(dp37
S'body'
p38
S'print e,c'
sg13
I0
sg26
S'1'
sS'parent'
p39
g1
sg14
S'New Rule'
sS'para'
p40
S'e:Attribute,c:Classifier'
sg19
S'This is the documentation of a Rule'
sg29
S'rule'
p41
sbasb.
|
