def test_model_with_local_scope_wrong_type():
"""
This is a basic test for the local scope provider
(basd case with wrong type).
"""
#################################
# 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.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots"),
})
#################################
# MODEL PARSING
#################################
with raises(textx.exceptions.TextXSemanticError, match=r'.*wrong_port.*'):
_ = my_meta_model.model_from_file(
abspath(dirname(__file__)) +
"/components_model1/example_wrong_type.components")
def test_model_with_local_scope_and_error():
#################################
# 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.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots")
})
#################################
# MODEL PARSING
#################################
with raises(textx.exceptions.TextXSemanticError,
match=r'.*Unknown objec.*input1.*SlotIn.*'):
my_model = my_meta_model.model_from_file(
abspath(dirname(__file__)) +
"/components_model1/example_err1.components")
def test_model_with_local_scope_and_bad_model_path():
"""
This is a basic 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":
# error (component is not a list)
scoping_providers.RelativeName("from_inst.component"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots"),
})
#################################
# MODEL PARSING
#################################
with raises(textx.exceptions.TextXError,
match=r'.*expected path to list in the model '
+ r'\(from_inst.component\).*'):
my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example.components"))
def test_model_with_local_scope_and_error():
"""
This is a basic test for the local scope provider (bad 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
#################################
with raises(textx.exceptions.TextXSemanticError,
match=r'.*Unknown objec.*input1.*SlotIn.*'):
my_meta_model.model_from_file(
join(abspath(dirname(__file__)),
"components_model1", "example_err1.components"))
def test_metamodel_provider_utf_16_le_basic_test():
"""
This test checks that the global MetaModel Provider
works (basic function). It uses utf-16-le for the model files.
"""
#################################
# META MODEL DEF
#################################
mm_components = metamodel_from_file(
join(abspath(dirname(__file__)), 'metamodel_provider_utf-16-le',
'Components.tx'))
mm_components.register_scope_providers({
"*.*":
scoping_providers.FQNImportURI(),
"Connection.from_port":
scoping_providers.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots"),
})
mm_users = metamodel_from_file(
join(abspath(dirname(__file__)), 'metamodel_provider_utf-16-le',
'Users.tx'))
mm_users.register_scope_providers({
"*.*": scoping_providers.FQNImportURI(),
})
clear_language_registrations()
register_language(
'components-dsl',
pattern='*.components',
description='demo',
metamodel=mm_components # or a factory
)
register_language(
'users-dsl',
pattern='*.users',
description='demo',
metamodel=mm_users # or a factory
)
#################################
# MODEL PARSING
#################################
my_model = mm_users.model_from_file(join(abspath(dirname(__file__)),
"metamodel_provider_utf-16-le",
"example.users"),
encoding='utf-16-le')
#################################
# TEST MODEL
#################################
user = get_unique_named_object_in_all_models(my_model, "pi")
action1 = get_unique_named_object_in_all_models(my_model, "action1")
assert user.instance is action1
def test_model_with_local_scope_postponed():
"""
This is a test for the local scope provider which checks that
the scope resolution is postponed at an intermediate stage.
This must be the case, since the order of object references is
exchanged in two differernt metamodels. This, we argue that (in the
absence of an additional sorting mechanisms) in one of both
cases the required reference to the "from_instance" must be unresolved
in the first resolution pass.
The check is done using white box information (postponed_counter).
"""
#################################
# META MODEL DEF
#################################
sp1 = scoping_providers.RelativeName("from_inst.component.slots")
my_meta_model1 = metamodel_from_file(
join(abspath(dirname(__file__)), 'components_model1', 'Components.tx'))
my_meta_model1.register_scope_providers({
"*.*":
scoping_providers.FQN(),
"Connection.from_port":
sp1,
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots")
})
sp2 = scoping_providers.RelativeName("from_inst.component.slots")
my_meta_model2 = metamodel_from_file(
join(abspath(dirname(__file__)), 'components_model2', 'Components.tx'))
my_meta_model2.register_scope_providers({
"*.*":
scoping_providers.FQN(),
"Connection.from_port":
sp2,
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots")
})
#################################
# MODEL PARSING
#################################
my_meta_model1.model_from_file(
join(abspath(dirname(__file__)), "components_model1",
"example.components"))
my_meta_model2.model_from_file(
join(abspath(dirname(__file__)), "components_model2",
"example.components"))
#################################
# TEST MODEL
#################################
assert sp1.postponed_counter > 0 or sp2.postponed_counter > 0
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_metamodel_provider_basic_test():
"""
This test checks that the global MetaModel Provider
works (basic function): It is checked that no filename patterns
are used twice. It is checked that the correct metamodel
is used to load a model (by loading a model constellation using
two metamodels).
"""
#################################
# META MODEL DEF
#################################
mm_components = metamodel_from_file(
join(abspath(dirname(__file__)), 'metamodel_provider',
'Components.tx'))
mm_components.register_scope_providers({
"*.*":
scoping_providers.FQNImportURI(),
"Connection.from_port":
scoping_providers.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots"),
})
mm_users = metamodel_from_file(
join(abspath(dirname(__file__)), 'metamodel_provider', 'Users.tx'))
mm_users.register_scope_providers({
"*.*": scoping_providers.FQNImportURI(),
})
scoping.MetaModelProvider.add_metamodel("*.components", mm_components)
scoping.MetaModelProvider.add_metamodel("*.users", mm_users)
with raises(Exception, match=r'.*pattern.*already registered.*'):
scoping.MetaModelProvider.add_metamodel("*.users", mm_users)
#################################
# MODEL PARSING
#################################
my_model = mm_users.model_from_file(
join(abspath(dirname(__file__)), "metamodel_provider",
"example.users"))
#################################
# TEST MODEL
#################################
user = get_unique_named_object_in_all_models(my_model, "pi")
action1 = get_unique_named_object_in_all_models(my_model, "action1")
assert user.instance is action1
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 get_survey_mm():
"""Returns the meta-model for survey-dsl language."""
current_dir = os.path.dirname(__file__)
grammar_path = os.path.join(current_dir, 'survey.tx')
object_processors = {
'SurveyContent': survey_content_object_processor,
'Question': question_object_processor,
'ParameterValue': parameter_value_object_processor,
}
# build metamodel
metamodel = metamodel_from_file(grammar_path,
classes=[Parameter, QuestionType],
builtins=get_built_in_question_types(),
global_repository=True)
metamodel.register_scope_providers({
"*.*":
scoping_providers.PlainNameImportURI(),
"ParameterValue.parameter":
scoping_providers.RelativeName("parent.type.parameters"),
})
metamodel.register_obj_processors(object_processors)
return metamodel
def test_metamodel_provider_utf_16_le_basic_test():
"""
This test checks that the global MetaModel Provider
works (basic function). It uses utf-16-le for the model files.
"""
#################################
# META MODEL DEF
#################################
mm_components = metamodel_from_file(
abspath(dirname(__file__)) +
'/metamodel_provider_utf-16-le/Components.tx')
mm_components.register_scope_providers({
"*.*":
scoping_providers.FQNImportURI(),
"Connection.from_port":
scoping_providers.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots"),
})
mm_users = metamodel_from_file(
abspath(dirname(__file__)) + '/metamodel_provider_utf-16-le/Users.tx')
mm_users.register_scope_providers({
"*.*": scoping_providers.FQNImportURI(),
})
scoping.MetaModelProvider.add_metamodel("*.components", mm_components)
scoping.MetaModelProvider.add_metamodel("*.users", mm_users)
#################################
# MODEL PARSING
#################################
my_model = mm_users.model_from_file(
abspath(dirname(__file__)) +
"/metamodel_provider_utf-16-le/example.users",
encoding='utf-16-le')
#################################
# TEST MODEL
#################################
user = get_unique_named_object_in_all_models(my_model, "pi")
action1 = get_unique_named_object_in_all_models(my_model, "action1")
assert user.instance is action1
def read_SLCO_model(m):
"""Read, post process, and type check an SLCO model"""
# create meta-model
slco_mm = metamodel_from_file(join(this_folder,
'../textx_grammars/slco2.tx'),
autokwd=True,
classes=[
Assignment, Composite, Expression,
ExprPrec1, ExprPrec2, ExprPrec3,
ExprPrec4, Primary, ExpressionRef,
Variable, VariableRef, Type, Action
])
# register processors
slco_mm.register_model_processor(construct_action_set)
slco_mm.register_model_processor(check_names)
slco_mm.register_model_processor(add_initial_to_states)
slco_mm.register_model_processor(add_variable_types)
#slco_mm.register_model_processor(set_default_type_size)
slco_mm.register_model_processor(set_default_channel_size)
slco_mm.register_model_processor(add_taus)
slco_mm.register_model_processor(fix_references)
#slco_mm.register_model_processor(simplify_statements)
# To do: Check receive statements for not receiving multiple values in the same variable
# To do: Check for absence of arrays (not single elements) as part of messages
slco_mm.register_scope_providers({
"*.*":
providers.FQN(),
"Initialisation.left":
providers.RelativeName("parent.type.variables"),
"Channel.port0":
providers.RelativeName("source.type.ports"),
"Channel.port1":
providers.RelativeName("target.type.ports"),
"ReceiveSignal.from":
providers.RelativeName("parent.parent.parent.type.ports"),
"SendSignal.to":
providers.RelativeName("parent.parent.parent.type.ports"),
})
# parse and return the model
return slco_mm.model_from_file(m)
def test_model_with_local_scope_postponed():
#################################
# META MODEL DEF
#################################
sp1 = scoping_providers.RelativeName("from_inst.component.slots")
my_meta_model1 = metamodel_from_file(
abspath(dirname(__file__)) + '/components_model1/Components.tx')
my_meta_model1.register_scope_providers({
"*.*":
scoping_providers.FQN(),
"Connection.from_port":
sp1,
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots")
})
sp2 = scoping_providers.RelativeName("from_inst.component.slots")
my_meta_model2 = metamodel_from_file(
abspath(dirname(__file__)) + '/components_model2/Components.tx')
my_meta_model2.register_scope_providers({
"*.*":
scoping_providers.FQN(),
"Connection.from_port":
sp2,
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots")
})
#################################
# MODEL PARSING
#################################
_ = my_meta_model1.model_from_file(
abspath(dirname(__file__)) + "/components_model1/example.components")
_ = my_meta_model2.model_from_file(
abspath(dirname(__file__)) + "/components_model2/example.components")
#################################
# TEST MODEL
#################################
assert sp1.postponed_counter > 0 or sp2.postponed_counter > 0
def test_metamodel_provder_basic_test():
#################################
# META MODEL DEF
#################################
mm_components = metamodel_from_file(
abspath(dirname(__file__)) + '/metamodel_provider/Components.tx')
mm_components.register_scope_providers({
"*.*": scoping_providers.FQNImportURI(),
"Connection.from_port":
scoping_providers.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots"),
})
mm_users = metamodel_from_file(
abspath(dirname(__file__)) + '/metamodel_provider/Users.tx')
mm_users.register_scope_providers({
"*.*": scoping_providers.FQNImportURI(),
})
scoping.MetaModelProvider.add_metamodel("*.components", mm_components)
scoping.MetaModelProvider.add_metamodel("*.users", mm_users)
with raises(Exception, match=r'.*pattern.*already registered.*'):
scoping.MetaModelProvider.add_metamodel("*.users", mm_users)
#################################
# MODEL PARSING
#################################
my_model = mm_users.model_from_file(
abspath(dirname(__file__)) + "/metamodel_provider/example.users")
#################################
# TEST MODEL
#################################
user = get_unique_named_object_in_all_models(my_model, "pi")
action1 = get_unique_named_object_in_all_models(my_model, "action1")
assert user.instance is action1
def get_meta_model(debug=False, **kwargs):
from itemlang.metamodel_formula import Sum, Mul, Dif, Div, Val, ScalarRef
grammar_file_name = 'grammar/CustomIDL.tx'
my_providers = {
"*.*":
scoping_providers.FQNImportURI(),
"ScalarRef.ref0":
scoping_providers.RelativeName("parent(Struct).attributes"),
"ScalarRef.ref1":
scoping_providers.RelativeName("ref0.type.attributes"),
"ScalarRef.ref2":
scoping_providers.RelativeName("ref1.type.attributes"),
}
my_object_processors = {
"ScalarRef": object_processors.check_scalar_ref,
"Struct": object_processors.CheckRawTypes(kwargs),
"ArrayDimension": object_processors.check_array_dimensions,
"ArrayAttribute": object_processors.check_array_attribute,
"RawType": object_processors.check_raw_type_has_defined_bits
}
this_folder = dirname(abspath(__file__))
mm = metamodel_from_file(os.path.join(this_folder, grammar_file_name),
debug=debug,
classes=[
Sum, Mul, Dif, Div, Val, ScalarRef, RawType,
Struct, ArrayAttribute, ScalarAttribute,
ArrayDimension
])
mm.register_scope_providers(my_providers)
mm.register_obj_processors(my_object_processors)
return mm
def test_metamodel_provider_basic_test():
"""
This test checks that the global MetaModel Provider
works (basic function): It is checked that no filename patterns
are used twice. It is checked that the correct metamodel
is used to load a model (by loading a model constellation using
two metamodels).
Note: the MetaModelProvider is obsolete. This test is fixed
in terms of how to handle the filename --> metamodel resolution
in textx >= 2.x
"""
#################################
# META MODEL DEF
#################################
mm_components = metamodel_from_file(
join(abspath(dirname(__file__)), 'metamodel_provider',
'Components.tx'))
mm_components.register_scope_providers({
"*.*":
scoping_providers.FQNImportURI(),
"Connection.from_port":
scoping_providers.RelativeName("from_inst.component.slots"),
"Connection.to_port":
scoping_providers.RelativeName("to_inst.component.slots"),
})
mm_users = metamodel_from_file(
join(abspath(dirname(__file__)), 'metamodel_provider', 'Users.tx'))
mm_users.register_scope_providers({
"*.*": scoping_providers.FQNImportURI(),
})
clear_language_registrations()
register_language(
'components-dsl',
pattern='*.components',
description='demo',
metamodel=mm_components # or a factory
)
register_language(
'users-dsl',
pattern='*.users',
description='demo',
metamodel=mm_users # or a factory
)
with raises(Exception, match=r'.*already registered.*'):
register_language(
'users-dsl',
pattern='*.users',
description='demo',
metamodel=mm_users # or a factory
)
#################################
# MODEL PARSING
#################################
my_model = mm_users.model_from_file(
join(abspath(dirname(__file__)), "metamodel_provider",
"example.users"))
#################################
# TEST MODEL
#################################
user = get_unique_named_object_in_all_models(my_model, "pi")
action1 = get_unique_named_object_in_all_models(my_model, "action1")
assert user.instance is action1
