def test_user_module_derived_from_mixin_(pygen_output_dir):
rootpkg = EPackage('derived_from_mixin')
c1 = EClass('MyClass')
c1.eOperations.append(EOperation('do_it'))
c1.eStructuralFeatures.append(EAttribute('any', EString, derived=True))
rootpkg.eClassifiers.append(c1)
c2 = EClass('MyOtherClass')
c2.eStructuralFeatures.append(EAttribute('other', EString, derived=True))
c2.eStructuralFeatures.append(EReference('toc', c1, derived=True))
c2.eSuperTypes.append(c1)
rootpkg.eClassifiers.append(c2)
mm = generate_meta_model(rootpkg, pygen_output_dir, user_module='user_provided.module')
c = mm.MyOtherClass(any='any', other='other')
assert isinstance(c, MyClassMixin)
assert isinstance(c, MyOtherClassMixin)
assert isinstance(c, mm.MyClass)
assert c.any == 'any'
c.mock_other.assert_called_once_with('other')
assert not c.do_it.called
c.do_it()
assert c.do_it.called
assert isinstance(mm.MyOtherClass._toc, EReference)
assert mm.MyOtherClass._toc.name == 'toc'
class AnyType(EObject, metaclass=MetaEClass):
mixed = EAttribute(eType=EFeatureMapEntry,
derived=False,
changeable=True,
iD=False,
upper=1)
any = EAttribute(eType=EFeatureMapEntry,
derived=True,
changeable=True,
upper=-1,
transient=True,
derived_class=DerivedAny)
anyAttribute = EAttribute(eType=EFeatureMapEntry,
derived=False,
changeable=True,
iD=False,
upper=1)
def __init__(self, *, mixed=None, any=None, anyAttribute=None, **kwargs):
if kwargs:
raise AttributeError('unexpected arguments: {}'.format(kwargs))
super().__init__()
if mixed:
self.mixed.update(mixed)
if any:
self.any.update(any)
if anyAttribute:
self.anyAttribute.update(anyAttribute)
class Book(EObject, metaclass=MetaEClass):
title = EAttribute(eType=EString)
pages = EAttribute(eType=EInteger)
category = EAttribute(eType=BookCategory,
default_value=BookCategory.ScienceFiction)
def __init__(self):
super().__init__()
def test__ecore_generator__manage_default_value_simple_types():
attribute = EAttribute('with_default', EString)
attribute.defaultValueLiteral = 'str_val'
result = EcoreGenerator.manage_default_value(attribute)
assert result == "'str_val'"
attribute.eType = EInt
attribute.defaultValueLiteral = '123456'
result = EcoreGenerator.manage_default_value(attribute)
assert result == 123456
def test__ecore_generator__manage_default_value_enumeration():
enumeration = EEnum('MyEnum', literals=('None_', 'A', 'B'))
attribute = EAttribute('with_default', enumeration)
attribute.defaultValueLiteral = 'A'
result = EcoreGenerator.manage_default_value(attribute)
assert result == 'MyEnum.A'
attribute.defaultValueLiteral = 'None_'
result = EcoreGenerator.manage_default_value(attribute)
assert result == 'MyEnum.None_'
attribute.defaultValueLiteral = 'None'
result = EcoreGenerator.manage_default_value(attribute)
assert result == 'MyEnum.None_'
def test_user_module_derived_collection(pygen_output_dir):
rootpkg = EPackage('derived_collection')
c1 = EClass('MyClass')
c1.eStructuralFeatures.append(EAttribute('any', EString, derived=True, upper=-1))
rootpkg.eClassifiers.append(c1)
c2 = EClass('MyOtherClass')
c2.eStructuralFeatures.append(EReference('other', c1, derived=True, upper=-1))
c2.eSuperTypes.append(c1)
rootpkg.eClassifiers.append(c2)
mm = generate_meta_model(rootpkg, pygen_output_dir)
c = mm.MyOtherClass()
assert isinstance(c, mm.MyOtherClass)
assert isinstance(c, mm.MyClass)
with pytest.raises(AttributeError):
len(c.any)
with pytest.raises(AttributeError):
len(c.other)
with pytest.raises(AttributeError):
c.any.append('testValue')
d = mm.MyClass()
assert not isinstance(d, mm.MyOtherClass)
assert isinstance(d, mm.MyClass)
with pytest.raises(AttributeError):
c.other.append(d)
class ProcessingInstruction(EObject, metaclass=MetaEClass):
data = EAttribute(eType=String, derived=False, changeable=True, iD=False)
target = EAttribute(eType=String, derived=False, changeable=True, iD=False)
def __init__(self, *, data=None, target=None, **kwargs):
if kwargs:
raise AttributeError('unexpected arguments: {}'.format(kwargs))
super().__init__()
if data is not None:
self.data = data
if target is not None:
self.target = target
class SimpleAnyType(AnyType):
_rawValue = EAttribute(eType=String,
derived=True,
changeable=True,
iD=False,
name='rawValue')
_value = EAttribute(eType=AnySimpleType,
derived=True,
changeable=True,
iD=False,
name='value')
instanceType = EReference(ordered=True, unique=True, containment=False)
@property
def rawValue(self):
return self._rawValue
@rawValue.setter
def rawValue(self, value):
self._rawValue = value
@property
def value(self):
return self._value
@value.setter
def value(self, value):
self._value = value
def __init__(self,
*,
rawValue=None,
value=None,
instanceType=None,
**kwargs):
super().__init__(**kwargs)
if rawValue is not None:
self.rawValue = rawValue
if value is not None:
self.value = value
if instanceType is not None:
self.instanceType = instanceType
class AnyType(EObject, metaclass=MetaEClass):
mixed = EAttribute(eType=EFeatureMapEntry,
derived=False,
changeable=True,
iD=False,
upper=1)
_any = EAttribute(eType=EFeatureMapEntry,
derived=True,
changeable=True,
iD=False,
upper=1,
name='any')
anyAttribute = EAttribute(eType=EFeatureMapEntry,
derived=False,
changeable=True,
iD=False,
upper=1)
@property
def any(self):
return self._any
@any.setter
def any(self, value):
self._any = value
def __init__(self, *, mixed=None, any=None, anyAttribute=None, **kwargs):
if kwargs:
raise AttributeError('unexpected arguments: {}'.format(kwargs))
super().__init__()
if mixed:
self.mixed.update(mixed)
if any:
self.any.update(any)
if anyAttribute:
self.anyAttribute.update(anyAttribute)
def test_class_with_features(pygen_output_dir):
rootpkg = EPackage('class_features')
class_ = EClass('MyClass')
rootpkg.eClassifiers.append(class_)
class_.eStructuralFeatures.append(EAttribute('number', EInt, changeable=False))
class_.eStructuralFeatures.append(EReference('ref', class_))
mm = generate_meta_model(rootpkg, pygen_output_dir)
generated_class = mm.eClassifiers['MyClass']
instance = generated_class(number=7)
assert instance.number == 7
assert not instance.ref
instance.ref = instance
assert instance.ref is instance
def test_user_module_default_values(pygen_output_dir):
rootpkg = EPackage('with_default_values')
e1 = EEnum('MyEnum', literals=('None_', 'A', 'B'))
rootpkg.eClassifiers.append(e1)
c1 = EClass('MyClass')
a1 = EAttribute('a1', EString)
a1.defaultValueLiteral = 'my_str'
a2 = EAttribute('a2', EInt)
a2.defaultValueLiteral = '7654321'
a3 = EAttribute('a3', e1)
a3.defaultValueLiteral = 'None'
c1.eStructuralFeatures.extend([a1, a2, a3])
rootpkg.eClassifiers.append(c1)
mm = generate_meta_model(rootpkg, pygen_output_dir)
assert mm.MyClass.a1.default_value == 'my_str'
assert mm.MyClass.a2.default_value == 7654321
assert mm.MyClass.a3.default_value == mm.MyEnum.None_
class AbstractA(EObject, metaclass=MetaEClass):
name = EAttribute(eType=EString)
class XMLTypeDocumentRoot(EObject, metaclass=MetaEClass):
mixed = EAttribute(eType=EFeatureMapEntry,
derived=False,
changeable=True,
upper=1)
cDATA = EAttribute(eType=String,
derived=True,
changeable=True,
upper=-1,
transient=True,
derived_class=DerivedCdata)
comment = EAttribute(eType=String,
derived=True,
changeable=True,
upper=-1,
transient=True,
derived_class=DerivedComment)
text = EAttribute(eType=String,
derived=True,
changeable=True,
upper=-1,
transient=True,
derived_class=DerivedText)
xMLNSPrefixMap = EAttribute(ordered=True, unique=True, upper=1)
xSISchemaLocation = EAttribute(ordered=True, unique=True, upper=1)
processingInstruction = EReference(
ordered=True,
unique=True,
containment=True,
derived=True,
upper=-1,
transient=True,
derived_class=DerivedProcessinginstruction)
def __init__(self,
*,
mixed=None,
xMLNSPrefixMap=None,
xSISchemaLocation=None,
cDATA=None,
comment=None,
processingInstruction=None,
text=None,
**kwargs):
if kwargs:
raise AttributeError('unexpected arguments: {}'.format(kwargs))
super().__init__()
if mixed:
self.mixed.update(mixed)
if cDATA:
self.cDATA.extend(cDATA)
if comment:
self.comment.extend(comment)
if text:
self.text.extend(text)
if xMLNSPrefixMap:
self.xMLNSPrefixMap.update(xMLNSPrefixMap)
if xSISchemaLocation:
self.xSISchemaLocation.update(xSISchemaLocation)
if processingInstruction:
self.processingInstruction.extend(processingInstruction)
class Writer(EObject, metaclass=MetaEClass):
name = EAttribute(eType=EString)
books = EReference(eType=Book, lower=1, upper=-1)
class XMLTypeDocumentRoot(EObject, metaclass=MetaEClass):
mixed = EAttribute(eType=EFeatureMapEntry,
derived=False,
changeable=True,
iD=False,
upper=1)
_cDATA = EAttribute(eType=String,
derived=True,
changeable=True,
iD=False,
upper=-1,
name='cDATA')
_comment = EAttribute(eType=String,
derived=True,
changeable=True,
iD=False,
upper=-1,
name='comment')
_text = EAttribute(eType=String,
derived=True,
changeable=True,
iD=False,
upper=-1,
name='text')
xMLNSPrefixMap = EAttribute(ordered=True, unique=True, upper=1)
xSISchemaLocation = EAttribute(ordered=True, unique=True, upper=1)
processingInstruction = EReference(ordered=True,
unique=True,
containment=True,
upper=-1)
@property
def cDATA(self):
return self._cDATA
@cDATA.setter
def cDATA(self, value):
self._cDATA = value
@property
def comment(self):
return self._comment
@comment.setter
def comment(self, value):
self._comment = value
@property
def text(self):
return self._text
@text.setter
def text(self, value):
self._text = value
def __init__(self,
*,
mixed=None,
xMLNSPrefixMap=None,
xSISchemaLocation=None,
cDATA=None,
comment=None,
processingInstruction=None,
text=None,
**kwargs):
if kwargs:
raise AttributeError('unexpected arguments: {}'.format(kwargs))
super().__init__()
if mixed:
self.mixed.update(mixed)
if cDATA:
self.cDATA.extend(cDATA)
if comment:
self.comment.extend(comment)
if text:
self.text.extend(text)
if xMLNSPrefixMap:
self.xMLNSPrefixMap.update(xMLNSPrefixMap)
if xSISchemaLocation:
self.xSISchemaLocation.update(xSISchemaLocation)
if processingInstruction:
self.processingInstruction.extend(processingInstruction)
class Employee(EObject, metaclass=MetaEClass):
name = EAttribute(eType=EString)
age = EAttribute(eType=EInteger)
def makeeattribute(proptag, idx, pkg, cls):
"""The EAttribute equivalent of `makeeclass`"""
attr = EAttribute(**makeattributeproperties(proptag, idx, pkg, cls))
idx.addtarget(proptag.attrs[XMIID], attr)
cls.eStructuralFeatures.append(attr)
return attr
