def test_model_with_imports_and_global_repo():
"""
Basic test for FQNImportURI + global_repository
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'interface_model1', 'Interface.tx'),
global_repository=True)
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"interface_model1", "model_b", "app.if"))
my_model2 = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"interface_model1", "model_b", "app.if"))
#################################
# TEST MODEL
#################################
userid = get_unique_named_object(my_model, "userid")
userid2 = get_unique_named_object(my_model2, "userid")
assert userid == userid2
assert userid.ref == userid2.ref
assert userid.ref.__class__.__name__ == "RawType"
def test_model_without_imports():
"""
Basic test for FQNImportURI (with a model not using imports)
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'interface_model1', 'Interface.tx'))
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"interface_model1", "model_a", "all_in_one.if"))
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
check_unique_named_object_has_class(my_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(my_model, "socket")
s1 = get_unique_named_object(my_model, "s1")
assert a == s1.ref
def test_model_with_imports_and_global_repo():
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(abspath(dirname(__file__)) +
'/interface_model1/Interface.tx',
global_repository=True)
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) + "/interface_model1/model_b/app.if")
my_model2 = my_meta_model.model_from_file(
abspath(dirname(__file__)) + "/interface_model1/model_b/app.if")
#################################
# TEST MODEL
#################################
userid = get_unique_named_object(my_model, "userid")
userid2 = get_unique_named_object(my_model2, "userid")
assert userid == userid2
assert userid.ref == userid2.ref
assert userid.ref.__class__.__name__ == "RawType"
def test_model_without_imports():
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
abspath(dirname(__file__)) + '/interface_model1/Interface.tx')
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) + "/interface_model1/model_a/all_in_one.if")
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
check_unique_named_object_has_class(my_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(my_model, "socket")
s1 = get_unique_named_object(my_model, "s1")
assert a == s1.ref
def test_globalimports_basic_test_with_distributed_model():
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
abspath(dirname(__file__)) + '/interface_model2/Interface.tx')
my_meta_model.register_scope_providers({
"*.*":
scoping_providers.FQNGlobalRepo(
abspath(dirname(__file__)) + "/interface_model2/model_b/*.if")
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) + "/interface_model2/model_b/app.if")
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
inner_model = my_model._tx_model_repository.all_models.filename_to_model[
abspath(dirname(__file__)) + "/interface_model2/model_b/base.if"]
check_unique_named_object_has_class(inner_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(inner_model, "socket")
s1 = get_unique_named_object(inner_model, "s1")
assert a == s1.ref
def test_model_without_imports():
"""
Basic test for FQNImportURI (with a model not using imports)
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'interface_model1', 'Interface.tx'))
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model1", "model_a",
"all_in_one.if"))
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
check_unique_named_object_has_class(my_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(my_model, "socket")
s1 = get_unique_named_object(my_model, "s1")
assert a == s1.ref
def test_model_with_imports_and_global_repo():
"""
Basic test for FQNImportURI + global_repository
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(join(abspath(dirname(__file__)),
'interface_model1',
'Interface.tx'),
global_repository=True)
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model1", "model_b",
"app.if"))
my_model2 = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model1", "model_b",
"app.if"))
#################################
# TEST MODEL
#################################
userid = get_unique_named_object(my_model, "userid")
userid2 = get_unique_named_object(my_model2, "userid")
assert userid == userid2
assert userid.ref == userid2.ref
assert userid.ref.__class__.__name__ == "RawType"
def test_resolve_model_path_with_lists():
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'components_model1', 'Components.tx'))
my_meta_model.register_scope_providers({
"*.*": scoping_providers.FQN(),
"Connection.from_port":
scoping_providers.ExtRelativeName("from_inst.component",
"slots",
"extends"),
"Connection.to_port":
scoping_providers.ExtRelativeName("to_inst.component",
"slots",
"extends"),
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_inherit2.components"))
#################################
# TEST MODEL
#################################
action2a = resolve_model_path(my_model,
"packages.usage.instances.action2",
True)
action2b = get_unique_named_object(my_model, "action2")
assert action2a is action2b
middle_a = resolve_model_path(my_model,
"packages.base.components.Middle",
True)
middle_b = get_unique_named_object(my_model, "Middle")
assert middle_a is middle_b
# test parent(...) with lists
action2a_with_parent = resolve_model_path(
action2a, "parent(Model).packages.usage.instances.action2", True)
assert action2a_with_parent == action2a
# test "normal" parent with lists
action2a_with_parent2 = resolve_model_path(
action2a, "parent.instances.action2", True)
assert action2a_with_parent2 == action2a
with raises(Exception, match=r'.*unexpected: got list in path for '
r'get_referenced_object.*'):
resolve_model_path(my_model,
"packages.usage.instances.action2",
False)
def test_reference_to_buildin_attribute():
# This test demonstrates how to link a textX model to
# an arbitrary other non textX model.
#
# "foreign_model" be an arbitrary object, e.g., a AST from another
# (non textX) meta model.
# We can (in combination with a special scope provider)
# reference (and combine) our textX model with this model from
# the (non textX) meta model object.
foreign_model = {"name": "Test", "value": 3}
# custom scope provider
def my_scope_provider(obj, attr, attr_ref):
pyobj = obj.pyobj
if attr_ref.obj_name in pyobj:
return pyobj[attr_ref.obj_name]
else:
raise Exception("{} not found".format(attr_ref.obj_name))
# create meta model
my_metamodel = metamodel_from_str(
metamodel_str, builtins={'foreign_model': foreign_model})
my_metamodel.register_scope_providers({
"Access.pyattr": my_scope_provider,
})
# read model
my_model = my_metamodel.model_from_str('''
access A1 foreign_model
access A2 foreign_model.name
access A3 foreign_model.value
''')
# check that the references are OK
A2_name = get_unique_named_object(my_model, "A2").pyattr
assert A2_name is foreign_model["name"]
A3_val = get_unique_named_object(my_model, "A3").pyattr
assert A3_val is foreign_model["value"]
# check error cases
with raises(Exception, match=r'.*noname not found.*'):
_ = my_metamodel.model_from_str('''
access A1 foreign_model
access A2 foreign_model.noname
''')
with raises(Exception, match=r'.*unknown_model.*'):
_ = my_metamodel.model_from_str('''
access A1 foreign_model
access A2 unknown_model.name
''')
with raises(Exception, match=r'.*unknown_model.*'):
_ = my_metamodel.model_from_str('''
access A1 unknown_model
access A2 foreign_model.name
''')
pass
def test_model_with_local_scope_and_circular_ref_via_two_models():
"""
Test for FQNGlobalRepo + circular references.
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'components_model1', 'Components.tx'),
global_repository=True)
global_scope = scoping_providers.FQNGlobalRepo(
join(abspath(dirname(__file__)),
"components_model1", "example_?.components"))
my_meta_model.register_scope_providers({
"*.*": global_scope,
"Connection.from_port":
scoping_providers.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots")
})
#################################
# MODEL PARSING
#################################
my_model_a = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_A.components"))
my_model_b = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_B.components"))
a_my_a = get_unique_named_object(my_model_a, "mya")
a_my_b = get_unique_named_object(my_model_a, "myb")
b_my_a = get_unique_named_object(my_model_b, "mya")
b_my_b = get_unique_named_object(my_model_b, "myb")
assert a_my_a != b_my_a
assert a_my_b != b_my_b
assert a_my_a.component == b_my_a.component # same component "class"
assert a_my_b.component == b_my_b.component # same component "class"
a_connections = get_children_of_type("Connection", my_model_a)
b_connections = get_children_of_type("Connection", my_model_b)
a_connection = list(filter(
lambda x: x.from_inst == a_my_a and x.to_inst == a_my_b,
a_connections))
b_connection = list(filter(
lambda x: x.from_inst == b_my_a and x.to_inst == b_my_b,
b_connections))
assert len(a_connection) == 1
assert len(b_connection) == 1
def test_reference_to_nontextx_attribute():
# This test demonstrates how to link a textX model to
# an arbitrary other non textX model.
# Here we use a json file as external model
# to deomstrate how to load external models on the fly.
# custom scope provider
def generic_scope_provider(obj, attr, attr_ref):
if not obj.pyobj:
from textx.scoping import Postponed
return Postponed()
if not hasattr(obj.pyobj, "data"):
import json
obj.pyobj.data = json.load(
open(abspath(dirname(__file__)) + "/" + obj.pyobj.filename))
if attr_ref.obj_name in obj.pyobj.data:
return obj.pyobj.data[attr_ref.obj_name]
else:
raise Exception("{} not found".format(attr_ref.obj_name))
# create meta model
my_metamodel = metamodel_from_str(metamodel_str)
my_metamodel.register_scope_providers({
"Access.pyattr":
generic_scope_provider,
})
# read model
my_model = my_metamodel.model_from_str('''
import "test_reference_to_nontextx_attribute/othermodel.json" as data
access A1 data.name
access A2 data.gender
''')
# check that the references are OK
A1_name = get_unique_named_object(my_model, "A1").pyattr
assert A1_name == "pierre"
A2_gender = get_unique_named_object(my_model, "A2").pyattr
assert A2_gender == "male"
with raises(Exception, match=r'.*noname.*'):
_ = my_metamodel.model_from_str('''
import "test_reference_to_nontextx_attribute/othermodel.json" as data
access A1 data.noname
access A2 data.gender
''')
with raises(Exception, match=r'.*filenotfound.*'):
_ = my_metamodel.model_from_str('''
import "test_reference_to_nontextx_attribute/filenotfound.json" as data
access A1 data.name
access A2 data.gender
''')
pass
def test_reference_to_nontextx_attribute():
# This test demonstrates how to link a textX model to
# an arbitrary other non textX model.
# Here we use a json file as external model
# to demonstrate how to load external models on the fly.
# custom scope provider
def generic_scope_provider(obj, attr, attr_ref):
if not obj.pyobj:
from textx.scoping import Postponed
return Postponed()
if not hasattr(obj.pyobj, "data"):
import json
obj.pyobj.data = json.load(open(
join(abspath(dirname(__file__)), obj.pyobj.filename)))
if attr_ref.obj_name in obj.pyobj.data:
return obj.pyobj.data[attr_ref.obj_name]
else:
raise Exception("{} not found".format(attr_ref.obj_name))
# create meta model
my_metamodel = metamodel_from_str(metamodel_str)
my_metamodel.register_scope_providers({
"Access.pyattr": generic_scope_provider,
})
# read model
my_model = my_metamodel.model_from_str('''
import "test_reference_to_nontextx_attribute/othermodel.json" as data
access A1 data.name
access A2 data.gender
''')
# check that the references are OK
A1_name = get_unique_named_object(my_model, "A1").pyattr
assert A1_name == "pierre"
A2_gender = get_unique_named_object(my_model, "A2").pyattr
assert A2_gender == "male"
with raises(Exception, match=r'.*noname.*'):
my_metamodel.model_from_str('''
import "test_reference_to_nontextx_attribute/othermodel.json" as data
access A1 data.noname
access A2 data.gender
''')
with raises(Exception, match=r'.*filenotfound.*'):
my_metamodel.model_from_str('''
import "test_reference_to_nontextx_attribute/filenotfound.json" as data
access A1 data.name
access A2 data.gender
''')
pass
def test_json_ref_dsl():
mm = json_ref_dsl.get_metamodel()
current_dir = os.path.dirname(__file__)
my_model = mm.model_from_file(
os.path.join(current_dir, 'models', 'ok.jref'))
# check that the references are OK
A1_name = get_unique_named_object(my_model, "A1").pyattr
assert A1_name == "pierre"
A2_gender = get_unique_named_object(my_model, "A2").pyattr
assert A2_gender == "male"
def test_model_with_local_scope():
"""
This is a basic test for the local scope provider (good case).
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'components_model1',
'Components.tx'))
my_meta_model.register_scope_providers({
"*.*": scoping_providers.FQN(),
"Connection.from_port":
scoping_providers.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots"),
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "components_model1",
"example.components"))
#################################
# TEST MODEL
#################################
# test local refs
action2 = get_unique_named_object(my_model, "action2")
action3 = get_unique_named_object(my_model, "action3")
connections = get_children_of_type("Connection", my_model)
selected_connections = list(filter(
lambda x: x.from_inst == action2 and x.to_inst == action3,
connections))
assert len(selected_connections) == 1
# test list of formats
input2 = get_unique_named_object(my_model, "input2")
assert len(input2.formats) == 3
format_names = map(lambda x: x.name, input2.formats)
assert "A" in format_names
assert "B" in format_names
assert "C" in format_names
assert "D" not in format_names
def test_globalimports_basic_test_with_single_model_file_and_global_repo():
"""
Basic test for the FQNGlobalRepo + global_repository.
Tests that two metamodels create the same objects for the
same input (when global_repository is used).
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(join(abspath(dirname(__file__)),
'interface_model2',
'Interface.tx'),
global_repository=True)
my_meta_model.register_scope_providers({
"*.*":
scoping_providers.FQNGlobalRepo(
join(abspath(dirname(__file__)), 'interface_model2', 'model_a',
'*.if'))
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model2", "model_a",
"all_in_one.if"))
my_model2 = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model2", "model_a",
"all_in_one.if"))
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
check_unique_named_object_has_class(my_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(my_model, "socket")
s1 = get_unique_named_object(my_model, "s1")
assert a == s1.ref
a2 = get_unique_named_object(my_model2, "socket")
assert a2 == a # with global repository
def test_model_with_circular_imports():
"""
Basic test for FQNImportURI + circular imports
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'interface_model1', 'Interface.tx'))
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"interface_model1", "model_c", "A.if"))
#################################
# TEST MODEL
#################################
imports = get_children_of_type("Import", my_model)
assert len(imports) > 0
for i in imports:
assert 1 == len(i._tx_loaded_models) # one file / load import
assert i.importURI in i._tx_loaded_models[0]._tx_filename
check_unique_named_object_has_class(my_model, "A", "Interface")
a = get_unique_named_object(my_model, "A")
a_self = get_children(lambda x: hasattr(x, 'name') and x.name == "self", a)
assert len(a_self) == 1
a_self = a_self[0]
a_other = get_children(
lambda x: hasattr(x, 'name') and x.name == "other", a)
assert len(a_other) == 1
a_other = a_other[0]
a_other_self = get_children(
lambda x: hasattr(x, 'name') and x.name == "self", a_other.ref)
assert len(a_other_self) == 1
a_other_self = a_other_self[0]
a_other_other = get_children(
lambda x: hasattr(x, 'name') and x.name == "other", a_other.ref)
assert len(a_other_other) == 1
a_other_other = a_other_other[0]
assert a_self.ref == a_other_other.ref
assert a_self.ref != a_other.ref
assert a_other.ref == a_other_self.ref
assert a_other.ref != a_other_other.ref
def test_reference_to_python_attribute():
# This test demonstrates how to link python objects to
# a textX model.
# "access" objects access python attributes.
from collections import namedtuple
Person = namedtuple('Person', 'first_name last_name zip_code')
p1 = Person('Tim', 'Foo', 123)
p2 = Person('Tom', 'Bar', 456)
sp = PythonScopeProvider({"p1": p1, "p2": p2})
# create meta model
my_metamodel = metamodel_from_str(metamodel_str)
my_metamodel.register_scope_providers({
"Access.pyobj": sp,
"Access.pyattr": sp
})
# read model
my_model = my_metamodel.model_from_str('''
access A_Tim p1.first_name
access A_123 p1.zip_code
access A_456 p2.zip_code
''')
# check that the references are OK
A_Tim = get_unique_named_object(my_model, "A_Tim").pyattr
assert A_Tim == "Tim"
A_123 = get_unique_named_object(my_model, "A_123").pyattr
assert A_123 == 123
A_456 = get_unique_named_object(my_model, "A_456").pyattr
assert A_456 == 456
with raises(Exception, match=r'.*unknown.*'):
my_metamodel.model_from_str('''
access A1 p1.unknown
''')
with raises(Exception, match=r'.*p3.*'):
my_metamodel.model_from_str('''
access A1 p3.first_anme
''')
pass
def test_model_with_imports():
"""
Basic test for FQNImportURI (good case)
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'interface_model1', 'Interface.tx'))
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"interface_model1", "model_b", "app.if"))
my_model2 = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"interface_model1", "model_b", "app.if"))
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
inner_model = my_model._tx_model_repository.all_models.filename_to_model[
join(abspath(dirname(__file__)),
"interface_model1", "model_b", "base.if")]
check_unique_named_object_has_class(inner_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(inner_model, "socket")
s1 = get_unique_named_object(inner_model, "s1")
userid = get_unique_named_object(my_model, "userid")
assert a == s1.ref
userid2 = get_unique_named_object(my_model2, "userid")
assert userid != userid2
assert userid.ref != userid2.ref
assert userid.ref.__class__.__name__ == "RawType"
def test_model_with_circular_imports():
"""
Basic test for FQNImportURI + circular imports
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'interface_model1', 'Interface.tx'))
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model1", "model_c",
"A.if"))
#################################
# TEST MODEL
#################################
imports = get_children_of_type("Import", my_model)
assert len(imports) > 0
for i in imports:
assert 1 == len(i._tx_loaded_models) # one file / load import
assert i.importURI in i._tx_loaded_models[0]._tx_filename
check_unique_named_object_has_class(my_model, "A", "Interface")
a = get_unique_named_object(my_model, "A")
a_self = get_children(lambda x: hasattr(x, 'name') and x.name == "self", a)
assert len(a_self) == 1
a_self = a_self[0]
a_other = get_children(lambda x: hasattr(x, 'name') and x.name == "other",
a)
assert len(a_other) == 1
a_other = a_other[0]
a_other_self = get_children(
lambda x: hasattr(x, 'name') and x.name == "self", a_other.ref)
assert len(a_other_self) == 1
a_other_self = a_other_self[0]
a_other_other = get_children(
lambda x: hasattr(x, 'name') and x.name == "other", a_other.ref)
assert len(a_other_other) == 1
a_other_other = a_other_other[0]
assert a_self.ref == a_other_other.ref
assert a_self.ref != a_other.ref
assert a_other.ref == a_other_self.ref
assert a_other.ref != a_other_other.ref
def test_globalimports_basic_test_with_single_model_file_and_global_repo():
"""
Basic test for the FQNGlobalRepo + global_repository.
Tests that two metamodels create the same objects for the
same input (when global_repository is used).
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'interface_model2',
'Interface.tx'),
global_repository=True)
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNGlobalRepo(
join(abspath(dirname(__file__)), 'interface_model2',
'model_a', '*.if'))})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model2",
"model_a", "all_in_one.if"))
my_model2 = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model2",
"model_a", "all_in_one.if"))
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
check_unique_named_object_has_class(my_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(my_model, "socket")
s1 = get_unique_named_object(my_model, "s1")
assert a == s1.ref
a2 = get_unique_named_object(my_model2, "socket")
assert a2 == a # with global repository
def test_model_with_imports():
"""
Basic test for FQNImportURI (good case)
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'interface_model1', 'Interface.tx'))
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model1", "model_b",
"app.if"))
my_model2 = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model1", "model_b",
"app.if"))
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
inner_model = my_model._tx_model_repository.all_models.filename_to_model[
join(abspath(dirname(__file__)), "interface_model1", "model_b",
"base.if")]
check_unique_named_object_has_class(inner_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(inner_model, "socket")
s1 = get_unique_named_object(inner_model, "s1")
userid = get_unique_named_object(my_model, "userid")
assert a == s1.ref
userid2 = get_unique_named_object(my_model2, "userid")
assert userid != userid2
assert userid.ref != userid2.ref
assert userid.ref.__class__.__name__ == "RawType"
def test_globalimports_basic_test_with_single_model_file():
"""
Basic test for the FQNGlobalRepo.
Tests that two metamodels create different objects for the
same input.
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
abspath(dirname(__file__)) + '/interface_model2/Interface.tx')
my_meta_model.register_scope_providers({
"*.*":
scoping_providers.FQNGlobalRepo(
abspath(dirname(__file__)) + "/interface_model2/model_a/*.if")
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) + "/interface_model2/model_a/all_in_one.if")
my_model2 = my_meta_model.model_from_file(
abspath(dirname(__file__)) + "/interface_model2/model_a/all_in_one.if")
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
check_unique_named_object_has_class(my_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(my_model, "socket")
s1 = get_unique_named_object(my_model, "s1")
assert a == s1.ref
a2 = get_unique_named_object(my_model2, "socket")
assert a2 != a # no global repository
def test_globalimports_basic_test_with_distributed_model():
"""
Basic test for the FQNGlobalRepo.
Tests that a reference points to the expected (python) object
located in the model.
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'interface_model2', 'Interface.tx'))
my_meta_model.register_scope_providers({
"*.*":
scoping_providers.FQNGlobalRepo(
join(abspath(dirname(__file__)), "interface_model2", "model_b",
"*.if"))
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)), "interface_model2", "model_b",
"app.if"))
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
inner_model = my_model._tx_model_repository.all_models.filename_to_model[
join(abspath(dirname(__file__)), "interface_model2", "model_b",
"base.if")]
check_unique_named_object_has_class(inner_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(inner_model, "socket")
s1 = get_unique_named_object(inner_model, "s1")
assert a == s1.ref
def test_get_referenced_object():
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
abspath(dirname(__file__)) + '/components_model1/Components.tx')
my_meta_model.register_scope_providers({
"*.*": scoping_providers.FQN(),
"Connection.from_port":
scoping_providers.ExtRelativeName("from_inst.component",
"slots",
"extends"),
"Connection.to_port":
scoping_providers.ExtRelativeName("to_inst.component",
"slots",
"extends"),
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) +
"/components_model1/example_inherit2.components")
#################################
# TEST MODEL
#################################
action2a = get_referenced_object(
None, my_model, "packages.usage.instances.action2")
action2b = get_unique_named_object(my_model, "action2")
assert action2a is action2b
middle_a = get_referenced_object(
None, my_model, "packages.base.components.Middle")
middle_b = get_unique_named_object(my_model, "Middle")
assert middle_a is middle_b
def test_globalimports_basic_test_with_distributed_model():
"""
Basic test for the FQNGlobalRepo.
Tests that a reference points to the expected (python) object
located in the model.
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'interface_model2', 'Interface.tx'))
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNGlobalRepo(
join(abspath(dirname(__file__)),
"interface_model2", "model_b", "*.if"))})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"interface_model2", "model_b", "app.if"))
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
inner_model = my_model._tx_model_repository.all_models.filename_to_model[
join(abspath(dirname(__file__)),
"interface_model2", "model_b", "base.if")]
check_unique_named_object_has_class(inner_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(inner_model, "socket")
s1 = get_unique_named_object(inner_model, "s1")
assert a == s1.ref
def test_globalimports_basic_test_with_single_model_file_and_global_repo():
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(abspath(dirname(__file__)) +
'/interface_model2/Interface.tx',
global_repository=True)
my_meta_model.register_scope_providers({
"*.*":
scoping_providers.FQNGlobalRepo(
abspath(dirname(__file__)) + "/interface_model2/model_a/*.if")
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) + "/interface_model2/model_a/all_in_one.if")
my_model2 = my_meta_model.model_from_file(
abspath(dirname(__file__)) + "/interface_model2/model_a/all_in_one.if")
#################################
# TEST MODEL
#################################
# check that "socket" is an interface
check_unique_named_object_has_class(my_model, "socket", "Interface")
# check that "s.s1" is a reference to the socket interface
a = get_unique_named_object(my_model, "socket")
s1 = get_unique_named_object(my_model, "s1")
assert a == s1.ref
a2 = get_unique_named_object(my_model2, "socket")
assert a2 == a # with global repository
def test_model_with_circular_imports():
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
abspath(dirname(__file__)) + '/interface_model1/Interface.tx')
my_meta_model.register_scope_providers(
{"*.*": scoping_providers.FQNImportURI()})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) + "/interface_model1/model_c/A.if")
#################################
# TEST MODEL
#################################
check_unique_named_object_has_class(my_model, "A", "Interface")
a = get_unique_named_object(my_model, "A")
a_self = get_children(lambda x: hasattr(x, 'name') and x.name == "self", a)
assert len(a_self) == 1
a_self = a_self[0]
a_other = get_children(lambda x: hasattr(x, 'name') and x.name == "other",
a)
assert len(a_other) == 1
a_other = a_other[0]
a_other_self = get_children(
lambda x: hasattr(x, 'name') and x.name == "self", a_other.ref)
assert len(a_other_self) == 1
a_other_self = a_other_self[0]
a_other_other = get_children(
lambda x: hasattr(x, 'name') and x.name == "other", a_other.ref)
assert len(a_other_other) == 1
a_other_other = a_other_other[0]
assert a_self.ref == a_other_other.ref
assert a_self.ref != a_other.ref
assert a_other.ref == a_other_self.ref
assert a_other.ref != a_other_other.ref
def test_get_list_of_concatenated_objects():
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)),
'components_model1', 'Components.tx'))
my_meta_model.register_scope_providers({
"*.*": scoping_providers.FQN(),
"Connection.from_port":
scoping_providers.ExtRelativeName("from_inst.component",
"slots",
"extends"),
"Connection.to_port":
scoping_providers.ExtRelativeName("to_inst.component",
"slots",
"extends"),
})
#################################
# MODEL PARSING
#################################
my_model1 = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_inherit1.components"))
my_model2 = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_inherit2.components"))
#################################
# TEST MODEL
#################################
# test extends A,B
start = get_unique_named_object(my_model1, "Start")
middle = get_unique_named_object(my_model1, "Middle")
end = get_unique_named_object(my_model1, "End")
inherited_classes = get_list_of_concatenated_objects(middle, "extends")
assert len(inherited_classes) == 3
assert inherited_classes[0] is middle
assert inherited_classes[1] is start
assert inherited_classes[2] is end
# test extends A extends B
start = get_unique_named_object(my_model2, "Start")
middle = get_unique_named_object(my_model2, "Middle")
end = get_unique_named_object(my_model2, "End")
inherited_classes = get_list_of_concatenated_objects(middle, "extends")
assert len(inherited_classes) == 3
assert inherited_classes[0] is middle
assert inherited_classes[1] is start
assert inherited_classes[2] is end
def test_model_with_local_scope_and_inheritance2():
"""
This is a more complicated test for the local scope provider.
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
abspath(dirname(__file__)) + '/components_model1/Components.tx')
my_meta_model.register_scope_providers({
"*.*":
scoping_providers.FQN(),
"Connection.from_port":
scoping_providers.ExtRelativeName("from_inst.component", "slots",
"extends"),
"Connection.to_port":
scoping_providers.ExtRelativeName("to_inst.component", "slots",
"extends"),
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) +
"/components_model1/example_inherit1.components")
#################################
# TEST MODEL
#################################
# test inherited ports are same (direct inheritance)
action1 = get_unique_named_object(my_model, "action1")
action2 = get_unique_named_object(my_model, "action2")
action3 = get_unique_named_object(my_model, "action3")
end = get_unique_named_object(my_model, "end")
connections = get_children_of_type("Connection", my_model)
selected_connections_12 = list(
filter(lambda x: x.from_inst == action1 and x.to_inst == action2,
connections))
selected_connections_3e = list(
filter(lambda x: x.from_inst == action3 and x.to_inst == end,
connections))
assert len(selected_connections_12) == 1
assert len(selected_connections_3e) == 1
assert selected_connections_12[0].to_port is selected_connections_3e[0].\
to_port # output3 is same
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) +
"/components_model1/example_inherit2.components")
#################################
# TEST MODEL
#################################
# test inherited ports are same
# (indirect inheritance: Middle -> Start -> End)
action1 = get_unique_named_object(my_model, "action1")
action2 = get_unique_named_object(my_model, "action2")
action3 = get_unique_named_object(my_model, "action3")
end = get_unique_named_object(my_model, "end")
connections = get_children_of_type("Connection", my_model)
selected_connections_12 = list(
filter(lambda x: x.from_inst == action1 and x.to_inst == action2,
connections))
selected_connections_3e = list(
filter(lambda x: x.from_inst == action3 and x.to_inst == end,
connections))
assert len(selected_connections_12) == 1
assert len(selected_connections_3e) == 1
assert selected_connections_12[0].to_port is selected_connections_3e[0].\
to_port # output3 is same
def test_model_with_local_scope_and_inheritance2():
"""
This is a more complicated test for the local scope provider.
"""
#################################
# META MODEL DEF
#################################
my_meta_model = metamodel_from_file(
join(abspath(dirname(__file__)), 'components_model1',
'Components.tx'))
my_meta_model.register_scope_providers({
"*.*": scoping_providers.FQN(),
"Connection.from_port":
scoping_providers.ExtRelativeName("from_inst.component",
"slots",
"extends"),
"Connection.to_port":
scoping_providers.ExtRelativeName("to_inst.component",
"slots",
"extends"),
})
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_inherit1.components"))
#################################
# TEST MODEL
#################################
# test inherited ports are same (direct inheritance)
action1 = get_unique_named_object(my_model, "action1")
action2 = get_unique_named_object(my_model, "action2")
action3 = get_unique_named_object(my_model, "action3")
end = get_unique_named_object(my_model, "end")
connections = get_children_of_type("Connection", my_model)
selected_connections_12 = list(filter(
lambda x: x.from_inst == action1 and x.to_inst == action2,
connections))
selected_connections_3e = list(filter(
lambda x: x.from_inst == action3 and x.to_inst == end,
connections))
assert len(selected_connections_12) == 1
assert len(selected_connections_3e) == 1
assert selected_connections_12[0].to_port is selected_connections_3e[0].\
to_port # output3 is same
#################################
# MODEL PARSING
#################################
my_model = my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_inherit2.components"))
#################################
# TEST MODEL
#################################
# test inherited ports are same
# (indirect inheritance: Middle -> Start -> End)
action1 = get_unique_named_object(my_model, "action1")
action2 = get_unique_named_object(my_model, "action2")
action3 = get_unique_named_object(my_model, "action3")
end = get_unique_named_object(my_model, "end")
connections = get_children_of_type("Connection", my_model)
selected_connections_12 = list(filter(
lambda x: x.from_inst == action1 and x.to_inst == action2,
connections))
selected_connections_3e = list(filter(
lambda x: x.from_inst == action3 and x.to_inst == end, connections))
assert len(selected_connections_12) == 1
assert len(selected_connections_3e) == 1
assert selected_connections_12[0].to_port is selected_connections_3e[0].\
to_port # output3 is same
