def test_generate_delta_cenreps(self):
project_dir = abspath('gen_project')
config = 'root2.confml'
output_dir = abspath('temp/gen_output_deltacenrep')
expected_dir = abspath('gen_expected_deltacenrep')
self.remove_if_exists(output_dir)
prj = api.Project(api.Storage.open(project_dir))
config = prj.get_configuration(config)
gc = plugin.GenerationContext(configuration=config,
output=output_dir)
# Get refs from the last layer
layer = config.get_configuration_by_index(-1)
refs = utils.distinct_array(layer.list_leaf_datas())
impls = plugin.get_impl_set(config, 'crml$')
impls = impls | plugin.get_impl_set(config, 'implml$')
impls = impls.filter_implementations(refs=refs)
gc.tags['crml'] = ['deltacenrep']
gc.changed_refs = refs
gc.filtering_disabled = True
impls.generate(gc)
impls.post_generate(gc)
output_dir = os.path.join(output_dir, 'deltacenreps')
self.assert_dir_contents_equal(output_dir, expected_dir, ['.svn'])
def test_generate(self):
orig_workdir = os.getcwd()
os.chdir(ROOT_PATH)
try:
OUTPUT_DIR = os.path.join(ROOT_PATH, 'output')
self.remove_if_exists(OUTPUT_DIR)
self.remove_if_exists(['hello.log', 'exec_in_output_test.log',])
fs = filestorage.FileStorage(testdata)
p = api.Project(fs)
config = p.get_configuration('product.confml')
context = plugin.GenerationContext(configuration=config,
output=OUTPUT_DIR)
impls = plugin.get_impl_set(config,'file2\.commandml$')
#impls.output = OUTPUT_DIR
impls.generate(context)
self.assert_file_content_equals('hello.log',
"Hello" + os.linesep +
"Cmd line args: ['-c', 'some_config.txt', '-d', 'some_dir', '-x']" + os.linesep)
self.assert_file_content_equals('exec_in_output_test.log',
os.path.normpath(OUTPUT_DIR) + os.linesep)
# Check that the log file of the command that should not be
# executed does not exist
self.assertFalse(os.path.exists("should_not_be_created.log"))
self.assertTrue(os.path.exists(os.path.join(OUTPUT_DIR,"helloworld.txt")))
self.assertEquals(len(context.generation_output), 1)
self.assertEquals(utils.relpath(context.generation_output[0].name, OUTPUT_DIR), 'helloworld.txt')
self.assertEquals(context.generation_output[0].implementation.ref, 'assets/s60/implml/file2.commandml')
finally:
os.chdir(orig_workdir)
def test_simple_generate_newline(self):
self.remove_if_exists(os.path.normpath("output/output/test_newline_win.txt"))
self.remove_if_exists(os.path.normpath("output/output/test_newline_unix.txt"))
(config,impl) = self.load_impl('Layer1/implml/newline.templateml')
gc = plugin.GenerationContext(configuration=config)
impl.generate(gc)
self.assertTrue(os.path.exists(os.path.normpath("output/output/test_newline_win.txt")))
self.assertTrue(os.path.exists(os.path.normpath("output/output/test_newline_unix.txt")))
result_file_win = None
try:
result_file_win = open(os.path.normpath("output/output/test_newline_win.txt"),'rb')
line = result_file_win.read()
self.assertEquals(line, "line1\r\nline2")
finally:
if result_file_win != None: result_file_win.close()
result_file_unix = None
try:
result_file_unix = open(os.path.normpath("output/output/test_newline_unix.txt"), 'rb')
line = result_file_unix.read()
self.assertEquals(line, "line1\nline2")
finally:
if result_file_unix != None: result_file_unix.close()
def test_simple_generate_prj_extfiles_with_filters(self):
self.remove_if_exists(os.path.normpath("output/output/test_ext_temp_file.txt"))
(config,impl) = self.load_impl('Layer1/implml/external_tempfile.templateml')
gc = plugin.GenerationContext(configuration=config)
impl.generate(gc)
self.assertTrue(os.path.exists(os.path.normpath("output/output/test_ext_temp_file.txt")))
result_file1 = None
try:
result_file1 = open(os.path.normpath("output/output/test_ext_temp_file.txt"))
lines = 0
if result_file1 != None:
for line in result_file1:
self.assertTrue(line == "2+3=-1")
lines += 1
else:
self.fail("No result file found: output/output/test_ext_temp_file.txt")
self.assertTrue(lines == 1, "Wrong number of lines generated.")
finally:
if result_file1 != None: result_file1.close()
def test_impl_container_generate_with_generation_contexts_tags(self):
container = plugin.ImplContainer("norm", None)
imp1 = TestPluginImplContainer.ImplTest("implml/test.content", None)
subcontainer1 = plugin.ImplContainer("implml/sub1.implml", None)
subcontainer1.append(imp1)
subcontainer2 = plugin.ImplContainer("implml/sub2.implml", None)
imp2a = TestPluginImplContainer.ImplTest("implml/copy:21.content",
None)
imp2a.set_tags({'target': ['rofs3', 'uda']})
imp2b = TestPluginImplContainer.ImplTest("implml/copy:24.content",
None)
imp2b.set_tags({'target': ['rofs3', 'uda']})
subcontainer2.append(imp2a)
subcontainer2.append(imp2b)
container.append(subcontainer1)
container.append(subcontainer2)
context = plugin.GenerationContext()
context.tags = {'target': ['rofs3'], 'foobar': ['test']}
container.generate(context)
self.assertFalse(imp1.generate_invoked)
self.assertTrue(imp2a.generate_invoked)
self.assertTrue(imp2a.generate_invoked)
self.assertEquals(sorted(context.executed_impls),
sorted([imp2a, imp2b]))
def test_save_load_report_data_with_some_content(self):
rdata = generation_report.ReportData()
p = api.Project(api.Storage.open(TEMP_DIR, 'w'))
config = api.Configuration('test.confml')
fea = config.create_feature('Foo')
fea.create_feature('Child1')
fea.create_feature('Child2')
c3 = fea.create_feature('Child3')
c3.value = 'test'
rdata.log = ['one', 'two', 'three']
p.add_configuration(config)
p.save()
rdata.context = plugin.GenerationContext(phase="pre",
tags={'target': 'rofs3'},
output='foo',
configuration=config,
project=p)
tmpfile = os.path.join(TEMP_DIR, 'repdata.dat')
generation_report.save_report_data(rdata, tmpfile)
rdata2 = generation_report.load_report_data(tmpfile)
self.assertEquals(repr(rdata), repr(rdata2))
self.assertEquals(rdata.log, rdata2.log)
self.assertEquals(rdata.log, rdata2.log)
self.assertEquals(rdata2.context.phase, 'pre')
self.assertEquals(rdata2.context.tags, {'target': 'rofs3'})
self.assertEquals(rdata2.context.output, 'foo')
self.assertEquals(rdata2.context.configuration.Foo.Child3.fqr,
'Foo.Child3')
self.assertEquals(rdata2.context.configuration.Foo.Child3.get_value(),
'test')
self.assertEquals(rdata2.context.configuration.Foo.Child3.value,
'test')
def test_impl_container_execute_pre_rules(self):
project = api.Project(
api.Storage.open(os.path.join(ROOT_PATH, 'ruleproject/rules'),
"a"))
config = project.get_configuration('root.confml')
implcontainer = plugin.get_impl_set(config, 'ruleml$')
ruleimpl = implcontainer.get_implementations_by_file(
'implml/container_with_rules.ruleml')[0]
context = plugin.GenerationContext(configuration=config)
context.phase = "pre"
ruleimpl.generate(context)
lastconfig = config.get_last_configuration()
self.assertEquals(lastconfig.get_path(), plugin.AUTOCONFIG_CONFML)
self.assertEquals(lastconfig.list_all_datas(), [
'imakerapi', 'imakerapi.outputLocation', 'StringConcatenationTest',
'StringConcatenationTest.Result1',
'StringConcatenationTest.Result2'
])
self.assertEquals(
lastconfig.get_data('imakerapi.outputLocation').get_ref(),
'outputLocation')
self.assertEquals(
lastconfig.get_data('imakerapi.outputLocation').get_value(), '2')
project.close()
def _execute_rules(self, project_location):
project = api.Project(api.Storage.open(os.path.join(ROOT_PATH, project_location)))
config = project.get_configuration('root.confml')
context = plugin.GenerationContext(configuration=config)
implcontainer = plugin.get_impl_set(config, r'\.ruleml$')
implcontainer.get_relation_container().execute(context)
lastconfig = config.get_last_configuration()
project.close()
def test_configuration_content_generate_with_refs2(self):
impl = self.load_impl(
'assets/s60/implml/test_content_with_refs3.content')
context = plugin.GenerationContext(output=self.output)
results = impl.generate(context)
self.assertTrue(
os.path.exists(
os.path.join(self.output, 'example/content2p2/override.txt')))
def test_configuration_content_generate_with_include_refs(self):
impl = self.load_impl(
'assets/s60/implml/test_content_with_sequence_refs.content')
context = plugin.GenerationContext(output=self.output)
results = impl.generate(context)
self.assertTrue(
os.path.exists(os.path.join(context.output,
'content/override.txt')))
def test_configuration_content_generate_capital_letters(self):
impl = self.load_impl(
'assets/s60/implml/test_content_capital_file_input.content')
context = plugin.GenerationContext(output=self.output)
results = impl.generate(context)
self.assertTrue(os.path.exists(context.output))
self.assertTrue(
os.path.exists(
os.path.join(context.output, 'content/test_CAP_letters.txt')))
def __init__(self, ref, configuration):
"""
Overloading the default constructor
"""
plugin.ImplBase.__init__(self, ref, configuration)
self.desc = ""
self.logger = logging.getLogger('cone.content(%s)' % self.ref)
self.errors = False
self.context = plugin.GenerationContext(configuration=configuration)
def test_simple_generate_prj4_with_filters(self):
self.remove_if_exists(os.path.normpath("output/output/test4a.txt"))
self.remove_if_exists(os.path.normpath("output/output/test4b.txt"))
self.remove_if_exists(os.path.normpath("output/output/test4c.txt"))
self.remove_if_exists(os.path.normpath("output/output/test4d.txt"))
(config,impl) = self.load_impl('Layer1/implml/file4.templateml')
#impl.context = {'name' : 'John Doe'}
gc = plugin.GenerationContext(configuration=config)
impl.generate(gc)
self.assertTrue(os.path.exists(os.path.normpath("output/output/test4a.txt")))
self.assertTrue(os.path.exists(os.path.normpath("output/output/test4b.txt")))
self.assertTrue(os.path.exists(os.path.normpath("output/output/test4c.txt")))
self.assertTrue(os.path.exists(os.path.normpath("output/output/test4d.txt")))
result_file1 = None
result_file2 = None
result_file3 = None
result_file4 = None
try:
result_file1 = open(os.path.normpath("output/output/test4a.txt"))
result_file2 = open(os.path.normpath("output/output/test4b.txt"))
result_file3 = open(os.path.normpath("output/output/test4c.txt"))
result_file4 = open(os.path.normpath("output/output/test4d.txt"))
if result_file1 != None:
for line in result_file1:
self.assertTrue(line == "'Hello John Doe!'")
else:
self.fail("No result file found: output/output/test4a.txt")
if result_file2 != None:
for line in result_file2:
self.assertTrue(line == "'Hello John Doe again!'")
else:
self.fail("No result file found: output/output/test4b.txt")
if result_file3 != None:
for line in result_file3:
self.assertTrue(line == "2+3=5")
else:
self.fail("No result file found: output/output/test4c.txt")
if result_file4 != None:
for line in result_file4:
self.assertTrue(line == "--6")
else:
self.fail("No result file found: output/output/test4d.txt")
finally:
if result_file1 != None: result_file1.close()
if result_file2 != None: result_file2.close()
if result_file3 != None: result_file3.close()
if result_file4 != None: result_file4.close()
def test_configuration_content_generate(self):
config = self.load_config()
impls = plugin.get_impl_set(config, '\.content$')
context = plugin.GenerationContext(output=self.output)
results = impls.generate(context)
self.assertTrue(os.path.exists(impls.output))
self.assertTrue(
os.path.exists(
os.path.join(context.output,
'content/prodX/jee/ProdX_specific.txt')))
def _execute_rules(self, impl_filter):
implcontainer = plugin.get_impl_set(self.config, impl_filter)
context = plugin.GenerationContext(configuration=self.config)
context.output = os.path.join(ROOT_PATH, 'temp/output')
if not os.path.exists(context.output):
os.makedirs(context.output)
implcontainer.generate(context)
return context.generation_output
def test_impl_container_execute_rules(self):
project = api.Project(api.Storage.open(os.path.join(ROOT_PATH,'ruleproject/rules'), "r" ))
config = project.get_configuration('root.confml')
implcontainer = plugin.get_impl_set(config, 'ruleml$')
context = plugin.GenerationContext(configuration=config)
implcontainer.generate(context)
lastconfig = config.get_last_configuration()
self.assertEquals(lastconfig.get_path(), plugin.AUTOCONFIG_CONFML)
self.assertEquals(lastconfig.get_data('imakerapi.outputLocation').get_ref(),'outputLocation')
self.assertEquals(lastconfig.get_data('imakerapi.outputLocation').get_value(),'2')
project.close()
def test_generate_from_template_generation_context_accessed(self):
OUTPUT_DIR = os.path.join(ROOT_PATH, 'temp/access_context')
self.recreate_dir(OUTPUT_DIR)
(config,impl) = self.load_impl('Layer1/implml/access_context.templateml')
context = plugin.GenerationContext(output=OUTPUT_DIR,
configuration=config)
context.tags = {'sometag': ['foo', 'bar']}
impl.generate(context)
OUTPUT_FILE = os.path.join(OUTPUT_DIR, 'access_context.txt')
self.assert_exists_and_contains_something(OUTPUT_FILE)
self.assert_file_content_equals(OUTPUT_FILE,
"Tags: {'sometag': ['foo', 'bar']}")
def test_configuration_content_generate_with_external_input(self):
impl = self.load_impl('assets/s60/implml/test_external_input.content')
context = plugin.GenerationContext(output=self.output)
results = impl.generate(context)
self.assertTrue(
os.path.exists(
os.path.join(context.output, 'content_external/abc.txt')))
self.assertTrue(
os.path.exists(
os.path.join(context.output,
'content_external/folder1/data.txt')))
self.assertTrue(
os.path.exists(
os.path.join(context.output,
'content_external2/folder2/setting.txt')))
def test_simple_generate_prj3(self):
self.remove_if_exists(os.path.normpath("output/output/test3.txt"))
(config,impl) = self.load_impl('Layer1/implml/file3.templateml')
gc = plugin.GenerationContext(configuration=config)
impl.generate(gc)
self.assertTrue(os.path.exists(os.path.normpath("output/output/test3.txt")))
result_file = None
try:
result_file = open(os.path.normpath("output/output/test3.txt"))
for line in result_file:
self.assertTrue(line == "'Hello John Doe!'")
finally:
if result_file != None: result_file.close()
def test_generate_from_project(self):
project_dir = abspath('testdata/generation/project')
config = 'root.confml'
output_dir = abspath('temp/generation/output')
expected_dir = abspath('testdata/generation/expected')
self.remove_if_exists(output_dir)
prj = api.Project(api.Storage.open(project_dir))
config = prj.get_configuration(config)
context = plugin.GenerationContext(configuration=config,
output=output_dir)
impls = plugin.get_impl_set(config)
impls.generate(context)
self.assert_dir_contents_equal(output_dir, expected_dir, ['.svn'])
def test_create_generator_from_project_and_generate_all(self):
orig_workdir = os.getcwd()
os.chdir(ROOT_PATH)
try:
output = os.path.join(ROOT_PATH, "temp/output_all")
self.recreate_dir(output)
prj = api.Project(api.Storage.open(os.path.join(ROOT_PATH,"imageproject")))
config = prj.get_configuration('product.confml')
context = plugin.GenerationContext(configuration=config, output=output)
context.filtering_disabled = True
impl_set = plugin.get_impl_set(config, 'imageml$')
self.assertEquals(len(impl_set), 5)
impl_set.generate(context)
def check_gen(p):
self.assert_exists_and_contains_something(os.path.join(output, p))
def check_not_gen(p):
self.assertFalse(os.path.exists(os.path.join(output, p)), "'%s' exists when it should not!" % p)
try:
check_gen('startup.mbm')
check_gen('startup_mif.mif')
check_not_gen('optional1_mbm.mbm')
check_gen('optional2_mbm.mbm')
check_not_gen('optional3_mbm.mbm')
check_not_gen('optional4_mbm.mbm')
check_not_gen('optional1_mif.mif')
check_gen('optional2_mif.mif')
check_not_gen('optional3_mif.mif')
check_not_gen('optional4_mif.mif')
check_gen('resource/apps/startup.mif')
check_gen('depth_from_ref_test_mbm.mbm')
check_gen('depth_from_ref_test_mif.mif')
except AssertionError, e:
if ' ' in ROOT_PATH:
self.fail("Known bug (#177): %s" % e)
else:
raise
finally:
os.chdir(orig_workdir)
def test_impl_container_with_condition(self):
logger = logging.getLogger('cone')
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
logger.addHandler(ch)
context = plugin.GenerationContext()
context.configuration = api.Configuration()
context.configuration.add_feature(api.Feature("test"))
context.configuration.add_feature(api.Feature("stringsub"), "test")
context.configuration.add_feature(api.Feature("intsub"), "test")
context.configuration.get_default_view().test.value = True
context.configuration.get_default_view(
).test.stringsub.value = "stringval"
context.configuration.get_default_view().test.intsub.value = 2
condition = rules.SimpleCondition("${test}", "true")
container = plugin.ImplContainer("norm", None)
container.condition = condition
imp1 = TestPluginImplContainer.ImplTest("implml/test.content", None)
container.append(imp1)
container.generate(context)
self.assertTrue(imp1.generate_invoked)
imp1.generate_invoked = False
context.configuration.get_default_view().test.value = False
container.generate(context)
self.assertFalse(imp1.generate_invoked)
imp1.generate_invoked = False
condition = rules.SimpleCondition("${test}", "false")
container.condition = condition
container.generate(context)
self.assertTrue(imp1.generate_invoked)
imp1.generate_invoked = False
context.configuration.get_default_view().test.value = True
container.generate(context)
self.assertFalse(imp1.generate_invoked)
imp1.generate_invoked = False
condition = rules.SimpleCondition("${test.intsub}", "1")
container.condition = condition
container.append(imp1)
container.generate(context)
self.assertFalse(imp1.generate_invoked)
context.configuration.get_default_view().test.intsub.value = 1
container.generate(context)
self.assertTrue(imp1.generate_invoked)
def test_simple_generate_prj(self):
self.remove_if_exists(os.path.normpath("output/output/test.txt"))
(config,impl) = self.load_impl('Layer1/implml/file2.templateml')
#impl.context = {'name' : 'some value'}
gc = plugin.GenerationContext(configuration=config)
impl.generate(gc)
self.assertTrue(os.path.exists(os.path.normpath("output/output/test.txt")))
result_file = None
try:
result_file = open(os.path.normpath("output/output/test.txt"))
for line in result_file:
self.assertTrue(line == "include AABBCC")
finally:
if result_file != None: result_file.close()
def _run_gen_test(self, layer, ignores=[]):
project_dir = abspath('project')
config = 'root%s.confml' % layer
output_dir = abspath('temp/gen_output%s' % layer)
expected_dir = abspath('expected/root%s' % layer)
self.remove_if_exists(output_dir)
prj = api.Project(api.Storage.open(project_dir))
config = prj.get_configuration(config)
context = plugin.GenerationContext(configuration=config,
output=output_dir)
context.filtering_disabled = True
impls = plugin.get_impl_set(config, 'gcfml$')
impls.generate(context)
self.assert_dir_contents_equal(output_dir, expected_dir,
['.svn'] + ignores)
def test_rule_debug_messages(self):
log_file, handler, logger = self._prepare_log('debug_msg_test.log')
project = None
try:
project = api.Project(api.Storage.open(os.path.join(ROOT_PATH,'ruleproject/rules'), "r" ))
config = project.get_configuration('root.confml')
implcontainer = plugin.get_impl_set(config, r'rules\.ruleml$')
context = plugin.GenerationContext(configuration=config)
implcontainer.generate(context)
self.assert_file_contains(log_file,
["Set imakerapi.outputLocationY = 'hello' from ConfigureRelation(ref='implml/rules.ruleml', lineno=8)",
"Set operations.minus = 18 from ConfigureRelation(ref='implml/rules.ruleml', lineno=9)",
"Set SequenceTest.Sequence1 = [['foo', 1], ['bar', 2], ['baz', 3]] from ConfigureRelation(ref='implml/rules.ruleml', lineno=23)"])
finally:
logger.removeHandler(handler)
if project: project.close()
def test_simple_generate_prj7_with_funcs_as_filters(self):
self.remove_if_exists(os.path.normpath("output/output/test7a.txt"))
self.remove_if_exists(os.path.normpath("output/output/test7b.txt"))
self.remove_if_exists(os.path.normpath("output/output/test7c.txt"))
(config,impl) = self.load_impl('Layer1/implml/file7.templateml')
gc = plugin.GenerationContext(configuration=config)
impl.generate(gc)
self.assert_exists_and_contains_something(os.path.normpath("output/output/test7a.txt"))
self.assert_exists_and_contains_something(os.path.normpath("output/output/test7b.txt"))
self.assert_exists_and_contains_something(os.path.normpath("output/output/test7c.txt"))
result_file1 = None
result_file2 = None
result_file3 = None
try:
result_file1 = open(os.path.normpath("output/output/test7a.txt"))
result_file2 = open(os.path.normpath("output/output/test7b.txt"))
result_file3 = open(os.path.normpath("output/output/test7c.txt"))
if result_file1 != None:
for line in result_file1:
self.assertTrue(line == "3 + 4 = 7")
else:
self.fail("No result file found: output/output/test7a.txt")
if result_file2 != None:
for line in result_file2:
self.assertTrue(line == "3 ** 4 = 81")
else:
self.fail("No result file found: output/output/test7b.txt")
if result_file3 != None:
for line in result_file3:
self.assertTrue((line.strip() == "2!=3") or (line.strip() == "5=5"))
else:
self.fail("No result file found: output/output/test7c.txt")
finally:
if result_file1 != None: result_file1.close()
if result_file2 != None: result_file2.close()
if result_file2 != None: result_file3.close()
def test_invalid_ref_in_template(self):
OUTPUT_DIR = os.path.join(ROOT_PATH, 'temp/invalid_ref')
self.recreate_dir(OUTPUT_DIR)
(config,impl) = self.load_impl('Layer1/implml/invalid_ref.templateml')
context = plugin.GenerationContext(output=OUTPUT_DIR,
configuration=config)
log_file, handler, logger = self._prepare_log('invalid_refs.log')
impl.generate(context)
logger.removeHandler(handler)
self.assert_file_content_equals(os.path.join(OUTPUT_DIR, 'invalid_ref_1.txt'), "")
self.assert_file_content_equals(os.path.join(OUTPUT_DIR, 'invalid_ref_2.txt'), "")
self.assert_file_content_equals(os.path.join(OUTPUT_DIR, 'invalid_ref_3.txt'), "")
self.assert_file_contains(log_file,
["TemplatemlImpl(ref='Layer1/implml/invalid_ref.templateml', type='templateml', lineno=2): Failed to generate output: NotFound: Feature 'Foo' not found",
"TemplatemlImpl(ref='Layer1/implml/invalid_ref.templateml', type='templateml', lineno=2): Failed to generate output: NotFound: Feature 'Feature1.Nonexistent' not found",
"TemplatemlImpl(ref='Layer1/implml/invalid_ref.templateml', type='templateml', lineno=2): Failed to generate output: NotFound: Feature 'Feature1.SequenceSetting.Nonexistent' not found"])
def test_unicode_in_template_and_value(self):
OUTPUT_DIR = os.path.join(ROOT_PATH, 'output', 'unicode_test')
self.remove_if_exists(OUTPUT_DIR)
fs = filestorage.FileStorage(testdata)
p = api.Project(fs)
config = p.get_configuration('root1.confml')
impls = plugin.get_impl_set(config,'unicode_template_test\.templateml$')
gc = plugin.GenerationContext(output=OUTPUT_DIR,
configuration=config)
impls.generate(gc)
self.assert_exists_and_contains_something(os.path.join(OUTPUT_DIR, "unicode_template_test.txt"))
# Check that the output exists and contains expected lines
f = open(os.path.join(OUTPUT_DIR, "unicode_template_test.txt"), "rb")
try: data = f.read().decode('utf-8')
finally: f.close()
self.assertTrue(data.find(u'Value of Feature1.UnicodeValueSetting: カタカナ') != -1)
self.assertTrue(data.find(u'Unicode from template: ελληνικά') != -1)
def test_generate_access_configuration(self):
self.remove_if_exists(os.path.normpath("output/access_configuration.txt"))
(config,impl) = self.load_impl('Layer1/implml/access_configuration.templateml')
gc = plugin.GenerationContext(configuration=config)
impl.generate(gc)
self.assertTrue(os.path.exists(os.path.normpath("output/access_configuration.txt")))
result_file1 = None
try:
result_file1 = open(os.path.normpath("output/access_configuration.txt"))
data = result_file1.read()
if result_file1 != None:
self.assertTrue(data.startswith("Configuration name: root1.confml"))
else:
self.fail("No result file found: output/access_configuration.txt")
finally:
if result_file1 != None: result_file1.close()
def test_generate(self):
os.environ['ncp_version'] = 'platforms'
os.environ['variants'] = 'variants'
output_dir = os.path.join(temp_dir, "new_project")
if os.path.exists(output_dir):
shutil.rmtree(output_dir)
expected_dir = os.path.join(ROOT_PATH, "expected/new_project")
oldPath = os.path.join(ROOT_PATH, 'old_structure/epoc32/rom/config')
fs = filestorage.FileStorage(oldPath)
p = api.Project(fs)
config = p.get_configuration('convert.confml')
context = plugin.GenerationContext(configuration=config,
output=output_dir)
impls = plugin.get_impl_set(config, '\.convertprojectml$')
context.filtering_disabled = True
impls.generate(context)
self.assert_dir_contents_equal(expected_dir, output_dir, ['.svn'])
