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_attribute_with_feature_id(pygen_output_dir): rootpkg = EPackage('id_attribute') c1 = EClass('MyClass') rootpkg.eClassifiers.append(c1) a1 = EAttribute('att', EString, iD=True) a2 = EAttribute('att2', EString) c1.eStructuralFeatures.extend([a1, a2]) mm = generate_meta_model(rootpkg, pygen_output_dir) assert isinstance(mm.MyClass.att, EAttribute) assert isinstance(mm.MyClass.att2, EAttribute) assert mm.MyClass.att.iD is True assert mm.MyClass.att2.iD is False
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
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_pythonic_names(pygen_output_dir): rootpkg = EPackage('pythonic_names') c1 = EClass('MyClass') rootpkg.eClassifiers.append(c1) a1 = EAttribute('att', EString, upper=-1) c1.eStructuralFeatures.append(a1) c2 = EClass('pass') rootpkg.eClassifiers.append(c2) a2 = EAttribute('else', EString, upper=-1) c2.eStructuralFeatures.append(a2) mm = generate_meta_model(rootpkg, pygen_output_dir) assert mm.eClassifiers['MyClass'] is mm.MyClass assert mm.eClassifiers['pass_'] is mm.pass_ assert isinstance(mm.pass_.else_, EAttribute) assert mm.pass_().else_ == set()
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_eattribute_derived_not_changeable(pygen_output_dir): rootpkg = EPackage('changeable_attribute') c1 = EClass('MyClass') rootpkg.eClassifiers.append(c1) att1 = EAttribute('att1', EString, derived=True, changeable=True) att2 = EAttribute('att2', EString, derived=True, changeable=False) c1.eStructuralFeatures.extend([att2, att1]) mm = generate_meta_model(rootpkg, pygen_output_dir) instance = mm.MyClass() assert instance.att1 is None assert instance.att2 is None instance.att1 = "test_value" assert instance.att1 == "test_value" with pytest.raises(AttributeError): instance.att2 = "test_value2"
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_
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_class_with_feature_many(pygen_output_dir): rootpkg = EPackage('manyfeatures') MyClass = EClass('MyClass') rootpkg.eClassifiers.append(MyClass) any_feature = EAttribute('any', EString, upper=-1) MyClass.eStructuralFeatures.append(any_feature) mm = generate_meta_model(rootpkg, pygen_output_dir) generated_class = mm.eClassifiers['MyClass'] instance = mm.MyClass() assert generated_class is mm.MyClass assert isinstance(mm.MyClass.any, EAttribute) assert instance.any == set()
def test_class_with_derived_features(pygen_output_dir): rootpkg = EPackage('simpleClasses') MyClass = EClass('MyClass') rootpkg.eClassifiers.append(MyClass) any_feature = EAttribute('any', EString, derived=True) MyClass.eStructuralFeatures.append(any_feature) mm = generate_meta_model(rootpkg, pygen_output_dir) generated_class = mm.eClassifiers['MyClass'] assert mm.MyClass is generated_class assert isinstance(mm.MyClass._any, EAttribute) assert mm.MyClass._any.derived is True assert mm.MyClass._any.name == 'any'
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_classifier_imports(pygen_output_dir): # super types and enums from another package have to be imported in using module: rootpkg = EPackage('import_test') ppkg = EPackage('provider') upkg = EPackage('user') rootpkg.eSubpackages.extend([ppkg, upkg]) super_class = EClass('SuperClass') enum = EEnum('AnEnum', literals=('A', 'B')) ppkg.eClassifiers.extend((super_class, enum)) derived_class = EClass('DerivedClass', superclass=super_class) derived_class.eStructuralFeatures.append(EAttribute('kind', enum)) upkg.eClassifiers.append(derived_class) # simply importing successully shows the imports have made the types visible mm = generate_meta_model(rootpkg, pygen_output_dir) assert mm
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)
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
class AbstractA(EObject, metaclass=MetaEClass): name = EAttribute(eType=EString)
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 Writer(EObject, metaclass=MetaEClass): name = EAttribute(eType=EString) books = EReference(eType=Book, lower=1, upper=-1)
class Employee(EObject, metaclass=MetaEClass): name = EAttribute(eType=EString) age = EAttribute(eType=EInteger)
class Library(EObject, metaclass=MetaEClass): name = EAttribute(eType=EString) address = EAttribute(eType=EString) employees = EReference(eType=Employee, upper=-1, containment=True) writers = EReference(eType=Writer, upper=-1, containment=True) books = EReference(eType=Book, upper=-1, containment=True)