--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/configurationengine/source/plugins/common/ConeTemplatePlugin/templatemlplugin/tests/unittest_templatemlplugin.py Thu Mar 11 17:04:37 2010 +0200
@@ -0,0 +1,675 @@
+# *-* coding: utf-8 *-*
+#
+# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+# All rights reserved.
+# This component and the accompanying materials are made available
+# under the terms of "Eclipse Public License v1.0"
+# which accompanies this distribution, and is available
+# at the URL "http://www.eclipse.org/legal/epl-v10.html".
+#
+# Initial Contributors:
+# Nokia Corporation - initial contribution.
+#
+# Contributors:
+#
+# Description:
+#
+
+import unittest, os, shutil, sys
+
+try:
+ from cElementTree import ElementTree, ElementInclude
+except ImportError:
+ try:
+ from elementtree import ElementTree, ElementInclude
+ except ImportError:
+ try:
+ from xml.etree import cElementTree as ElementTree
+ except ImportError:
+ from xml.etree import ElementTree
+
+import __init__
+from templatemlplugin import templatemlplugin
+from types import NoneType
+from testautomation.base_testcase import BaseTestCase
+from testautomation.utils import hex_to_bindata
+
+from cone.public import exceptions,plugin,api,utils
+from cone.storage import filestorage
+from cone.confml import implml
+
+# Hardcoded value of testdata folder that must be under the current working dir
+ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
+testdata = os.path.join(ROOT_PATH,'project')
+
+TEMPML_DOC1 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \
+ "<templateml xmlns=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \
+ "<desc>Desc</desc>" \
+ "<output file=\"test.txt\" encoding=\"UTF-16\">" \
+ "<template extension=\"foo/foobar:MyClass\">ABCDF</template>" \
+ "</output>" \
+ "<filter name=\"test_filter\">lambda a,b: a+b</filter>" \
+ "</templateml>"
+
+TEMPML_DOC2 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \
+ "<templateml xmlns=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \
+ "<desc>Desc</desc>" \
+ "<output file=\"test.txt\" encoding=\"UTF-16\">" \
+ "<template extension=\"foo/foobar:MyClass\"><xi:include href=\"project/templates/template.xml\" parse=\"xml\"/></template>" \
+ "</output>" \
+ "<filter name=\"test_filter\">lambda a,b: a+b</filter>" \
+ "</templateml>"
+
+TEMPML_DOC3 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \
+ "<templateml xmlns=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \
+ "<desc>Desc</desc>" \
+ "<output file=\"test.txt\" encoding=\"UTF-16\">" \
+ "<template extension=\"foo/foobar:MyClass\"><xi:include href=\"project/templates/template.xml\" parse=\"xml\"/></template>" \
+ "</output>" \
+ "<filter name=\"test_filter\">lambda a,b: a+b</filter>" \
+ "</templateml>"
+
+TEMPML_DOC4 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \
+ "<templateml xmlns=\"http://www.s60.com/xml/templateml/1\">" \
+ "<output file=\"test.txt\" encoding=\"ascii\">" \
+ "<template file=\"../../templates/template.xml\"/>" \
+ "</output>" \
+ "<filter name=\"test_filter\" file=\"../../filter/filter.py\"/>" \
+ "</templateml>"
+
+TEMPML1 = "<ns0:output encoding=\"ASCII\" file=\"test.txt\" xmlns:ns0=\"http://www.s60.com/xml/templateml/1\">" \
+ "<ns0:template extension=\"foo/foobar:MyClass\">ABCDF</ns0:template>" \
+ "</ns0:output>"
+
+TEMPML2 = "<ns0:output encoding=\"ASCII\" file=\"test.txt\" xmlns:ns0=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \
+ "<ns0:template extension=\"foo/foobar:MyClass\">" \
+ "include AABBCC" \
+ "</ns0:template>" \
+ "</ns0:output>"
+
+TEMPML3 = "<ns0:output encoding=\"ASCII\" file=\"test.txt\" xmlns:ns0=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \
+ "<ns0:template extension=\"foo/foobar:MyClass\">" \
+ "include AABBCC" \
+ "</ns0:template>" \
+ "<filter name=\"test_filter\">lambda a,b: a+b</filter>" \
+ "</ns0:output>"
+
+TEMPML4 = "<ns0:output encoding=\"ASCII\" file=\"test.txt\" xmlns:ns0=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \
+ "<ns0:template file=\"../../templates/template.xml\"/>" \
+ "<filter name=\"test_filter\" file=\"../../filter/filter.py\"/>" \
+ "</ns0:output>"
+
+
+def impl_from_resource(resource_ref, configuration):
+ doc_root = plugin.ReaderBase._read_xml_doc_from_resource(resource_ref, configuration)
+ readers = { templateml.TemplatemlImplReader.NAMESPACE: templateml.TemplatemlImplReader }
+ ns = utils.xml.split_tag_namespace(doc_root.tag)[0]
+ if ns in readers:
+ return readers[ns].read_impl(resource_ref, configuration, doc_root)
+ else:
+ return None
+
+class TestTemplatemlPlugin(BaseTestCase):
+ def setUp(self):
+ self.curdir = os.getcwd()
+ self.output = os.path.join(ROOT_PATH, 'output')
+ os.chdir(os.path.join(ROOT_PATH))
+
+ def tearDown(self):
+ os.chdir(self.curdir)
+
+ def load_config(self, config):
+ fs = filestorage.FileStorage(testdata)
+ p = api.Project(fs)
+ return p.get_configuration(config)
+
+ def load_impl(self, resource_ref, config='root1.confml'):
+ configuration = self.load_config(config)
+ pattern = '^' + resource_ref.replace('.', r'\.') + '$'
+ impls = plugin.get_impl_set(configuration, pattern)
+ impls.output = self.output
+ impl_list = impls.get_implementations_by_file(resource_ref)
+ self.assertEquals(1, len(impl_list))
+ return impl_list[0]
+
+ def test_parse_desc(self):
+ impl = self.load_impl('Layer1/implml/file1.templateml')
+ self.assertEqual("Description field text", impl.reader.desc)
+
+ def test_parse_output_with_file_ref(self):
+ impl = self.load_impl('Layer1/implml/output_with_ref.templateml')
+ self.assertEquals(impl.list_output_files(), [os.path.normpath('output/confmlref_filename.txt')])
+
+ def test_parse_outputs(self):
+ impl = self.load_impl('Layer1/implml/file1.templateml')
+ outputs = []
+ output1 = templatemlplugin.OutputFile()
+ output1.set_encoding("UTF-16")
+ output1.set_filename("test.txt")
+ output1.set_path('')
+ temp1 = templatemlplugin.TempFile()
+ temp1.set_template(u'ABC kissa k\xe4velee')
+ output1.set_template(temp1)
+ outputs.append(output1)
+
+ output2 = templatemlplugin.OutputFile()
+ output2.set_encoding("UTF-16")
+ output2.set_filename("test2.txt")
+ output2.set_path("output")
+ temp2 = templatemlplugin.TempFile()
+ temp2.set_template('AABBCC')
+ output2.set_template(temp2)
+ outputs.append(output2)
+
+ output3 = templatemlplugin.OutputFile()
+ output3.set_encoding("UTF-8")
+ output3.set_filename("test3.txt")
+ output3.set_path('')
+ temp3 = templatemlplugin.TempFile()
+ temp3.set_template(u'ABC kissa k\xe4velee')
+ output3.set_template(temp3)
+
+ outputs.append(output3)
+
+ self.assertNotEqual(impl.reader.outputs, None)
+ self.assertEqual(outputs[0].encoding, impl.reader.outputs[0].encoding)
+ self.assertEqual(outputs[0].filename, impl.reader.outputs[0].filename)
+ self.assertEqual(outputs[0].path, impl.reader.outputs[0].path)
+ self.assertEqual(outputs[0].template.template, impl.reader.outputs[0].template.template)
+ self.assertEqual(outputs[0].template.extensions, impl.reader.outputs[0].template.extensions)
+ self.assertEqual(outputs[0].template.filters, impl.reader.outputs[0].template.filters)
+ self.assertEqual(outputs[0].template, impl.reader.outputs[0].template)
+ self.assertEqual(outputs[0], impl.reader.outputs[0])
+
+ self.assertEqual(outputs[1].encoding, impl.reader.outputs[1].encoding)
+ self.assertEqual(outputs[1].filename, impl.reader.outputs[1].filename)
+ self.assertEqual(outputs[1].path, impl.reader.outputs[1].path)
+ #self.assertEqual(outputs[1].template.template, impl.reader.outputs[1].template.template)
+ self.assertEqual(outputs[1].template.extensions, impl.reader.outputs[1].template.extensions)
+ self.assertEqual(outputs[1].template.filters, impl.reader.outputs[1].template.filters)
+ #self.assertEqual(outputs[1].template, impl.reader.outputs[1].template)
+ #self.assertEqual(outputs[1], impl.reader.outputs[1])
+
+ self.assertEqual(outputs[2].encoding, impl.reader.outputs[2].encoding)
+ self.assertEqual(outputs[2].filename, impl.reader.outputs[2].filename)
+ self.assertEqual(outputs[2].path, impl.reader.outputs[2].path)
+ #self.assertEqual(outputs[2].template.template, impl.reader.outputs[2].template.template)
+ self.assertEqual(outputs[2].template.extensions, impl.reader.outputs[2].template.extensions)
+ self.assertEqual(outputs[2].template.filters, impl.reader.outputs[2].template.filters)
+ #self.assertEqual(outputs[2].template, impl.reader.outputs[2].template)
+
+ #self.assertEqual(outputs[2], impl.reader.outputs[2])
+
+ def test_parse_outputfile(self):
+ output1 = templatemlplugin.OutputFile()
+ output2 = templatemlplugin.OutputFile()
+
+ self.assertEqual(output1, output2)
+ self.assertEqual(output1.encoding, output2.encoding)
+ self.assertEqual(output1.path, output2.path)
+ self.assertEqual(output1.filename, output2.filename)
+
+ output1.set_encoding("utf-8")
+ output2.set_encoding("utf-8")
+
+ self.assertEqual(output1, output2)# utf-8, utf-8
+
+ output1.set_encoding("utf-16")
+
+ self.assertNotEqual(output1, output2)#utf-16, utf-8
+
+ output2.set_encoding("utf-16")
+
+ self.assertEqual(output1, output2)#utf-16, utf-16
+
+ def test_parse_template(self):
+ reader = templatemlplugin.TemplatemlImplReader()
+ reader.fromstring(TEMPML_DOC1)
+
+ temp1 = reader.parse_template(ElementTree.fromstring(TEMPML1))
+ temp2 = templatemlplugin.TempFile()
+ temp2.set_template("ABCDF")
+
+ self.assertEqual(temp1.template, temp2.template)
+ self.assertEqual(temp1.extensions, temp2.extensions)
+ self.assertEqual(temp1.filters, temp2.filters)
+ self.assertEqual(temp1, temp2)
+
+ def test_parse_template_from_xinclude(self):
+ try:
+ reader = templatemlplugin.TemplatemlImplReader()
+ reader.fromstring(TEMPML_DOC2)
+
+ temp1 = reader.parse_template(ElementTree.fromstring(TEMPML2))
+ temp2 = templatemlplugin.TempFile()
+ temp2.set_template("include AABBCC")
+ except exceptions.ParseError, e:
+ self.fail("Known bug: ticket #2007")
+
+ self.assertEqual(temp1.template, temp2.template)
+ self.assertEqual(temp1.extensions, temp2.extensions)
+ self.assertEqual(temp1.filters, temp2.filters)
+ self.assertEqual(temp1, temp2)
+
+ def test_parse_template_filter(self):
+ try:
+ reader = templatemlplugin.TemplatemlImplReader()
+ reader.fromstring(TEMPML_DOC3)
+ filters1 = reader.filters
+ filter2 = templatemlplugin.Filter()
+ filter2.set_code("lambda a,b: a+b")
+ filter2.set_name("test_filter")
+ except exceptions.ParseError, e:
+ self.fail( "Known bug: ticket #2007")
+ self.assertEqual(filters1[0].name, filter2.name)
+ self.assertEqual(filters1[0].code, filter2.code)
+ self.assertEqual(filters1[0], filter2)
+
+ def test_parse_template_filter(self):
+ class DummyConfiguration(object):
+ def get_resource(self, ref):
+ class DummyResource(object):
+ def read(self): return ''
+ def close(self): return None
+ return DummyResource()
+ def get_default_view(self): return None
+ reader = templatemlplugin.TemplatemlImplReader('foo/implml/bar.implml', DummyConfiguration())
+ reader.fromstring(TEMPML_DOC4)
+
+ filters1 = reader.filters
+ filter2 = templatemlplugin.Filter()
+ filter2.set_code(None)
+ filter2.set_name("test_filter")
+ filter2.set_path("../../filter/filter.py")
+ temp1 = reader.parse_template(ElementTree.fromstring(TEMPML4))
+ temp2 = templatemlplugin.TempFile()
+ temp2.set_template('')
+ temp2.set_path('')
+
+ self.assertEqual(filters1[0].name, filter2.name)
+ self.assertEqual(filters1[0].code, filter2.code)
+ self.assertEqual(filters1[0].path, filter2.path)
+ self.assertEqual(filters1[0], filter2)
+ self.assertEqual(temp1.template, temp2.template)
+ self.assertEqual(temp1.extensions, temp2.extensions)
+ self.assertEqual(temp1.filters, temp2.filters)
+ self.assertEqual(temp1, temp2)
+
+ def test_simple_generate_prj(self):
+
+ self.remove_if_exists(os.path.normpath("output/output/test.txt"))
+
+ impl = self.load_impl('Layer1/implml/file2.templateml')
+ #impl.context = {'name' : 'some value'}
+ impl.generate()
+
+ 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 test_simple_generate_prj3(self):
+
+ self.remove_if_exists(os.path.normpath("output/output/test3.txt"))
+
+ impl = self.load_impl('Layer1/implml/file3.templateml')
+ impl.generate()
+
+ 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_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"))
+
+ impl = self.load_impl('Layer1/implml/file4.templateml')
+ #impl.context = {'name' : 'John Doe'}
+ impl.generate()
+
+ 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_simple_generate_prj_extfiles_with_filters(self):
+
+ self.remove_if_exists(os.path.normpath("output/output/test_ext_temp_file.txt"))
+
+ impl = self.load_impl('Layer1/implml/external_tempfile.templateml')
+
+ impl.generate()
+
+ 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_generate_prj1(self):
+
+ self.remove_if_exists(os.path.normpath("output/output/test5a.txt"))
+
+ impl = self.load_impl('Layer1/implml/file5.templateml')
+ impl.generate()
+ self.assertTrue(os.path.exists(os.path.normpath("output/output/test5a.txt")))
+
+ result_file1 = None
+ try:
+ result_file1 = open(os.path.normpath("output/output/test5a.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/test5a.txt")
+ finally:
+ if result_file1 != None: result_file1.close()
+
+ def test_generate_access_configuration(self):
+
+ self.remove_if_exists(os.path.normpath("output/access_configuration.txt"))
+
+ impl = self.load_impl('Layer1/implml/access_configuration.templateml')
+ impl.generate()
+ 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_create_context_dict1(self):
+ impl = self.load_impl('Layer1/implml/file6.templateml')
+ impl.context = impl.create_dict()
+ impl.generate()
+
+ def test_list_output_files(self):
+ impl = self.load_impl('Layer1/implml/file1.templateml')
+ impl.set_output_root('outdir')
+ output_files = impl.list_output_files()
+ expected = map(lambda n: os.path.normpath(n), [
+ 'outdir/test.txt',
+ 'outdir/output/test2.txt',
+ 'outdir/test3.txt',
+ 'outdir/output/test4.txt',
+ 'outdir/some/test/path/test5.txt',
+ ])
+ self.assertEquals(sorted(output_files), sorted(expected))
+
+ def test_has_ref(self):
+ impl = self.load_impl('Layer1/implml/has_ref_template_test2.templateml')
+ self.assertEquals(impl.has_ref('Feature1.StringSetting_not_found'), False)
+ self.assertEquals(impl.has_ref('Feature1.StringSetting1'), True)
+ self.assertEquals(impl.has_ref('Feature2'), True)
+ self.assertEquals(impl.has_ref('Feature2.set1.sub1'), True)
+ self.assertEquals(impl.has_ref('Feature2.set1.sub2'), True)
+ self.assertEquals(impl.has_ref('Feature1.UnicodeValueSetting'), True)
+
+ def test_has_ref_external_template(self):
+ impl = self.load_impl('Layer1/implml/has_ref_template_test3.templateml')
+ self.assertEquals(impl.has_ref('Feature1.StringSetting_not_found'), False)
+ self.assertEquals(impl.has_ref('Feature1.StringSetting1'), True)
+ self.assertEquals(impl.has_ref('Feature2'), True)
+ self.assertEquals(impl.has_ref('Feature2.set1.sub1'), True)
+ self.assertEquals(impl.has_ref('Feature2.set1.sub2'), True)
+ self.assertEquals(impl.has_ref('Feature1.UnicodeValueSetting'), True)
+
+ def test_has_ref_with_featree(self):
+ impl = self.load_impl('Layer1/implml/has_ref_template_test.templateml')
+ self.assertEquals(impl.has_ref('Feature1.StringSetting'), True)
+ self.assertEquals(impl.has_ref('Feature2.StringSetting'), True)
+
+ 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$')
+ impls.output = OUTPUT_DIR
+ impls.generate()
+ 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_create_context_dict_and_list(self):
+ config = self.load_config('create_dict_test.confml')
+ impls = plugin.get_impl_set(config, r'^create_dict_test/implml/test\.templateml$')
+ self.assertEquals(1, len(impls))
+ impl = iter(impls).next()
+ context = impl.create_dict()
+ feat_tree = context['feat_tree']
+ feat_list = context['feat_list']
+ self.assertEqual(context['configuration'], config)
+
+ # Check the created dictionary
+ expected_tree_file = os.path.join(ROOT_PATH, 'create_dict_test', 'expected_tree.txt')
+ expected_tree = eval(self.read_data_from_file(expected_tree_file).replace('\r', ''))
+ if feat_tree != expected_tree:
+ dir = os.path.join(ROOT_PATH, "temp", "create_dict_test", "tree")
+ self.create_dir(dir)
+ filename = os.path.join(dir, "expected.txt")
+ self.write_data_to_file(filename, self.feature_tree_to_str(expected_tree))
+ filename = os.path.join(dir, "actual.txt")
+ self.write_data_to_file(filename, self.feature_tree_to_str(feat_tree))
+ self.fail("Feature tree is not what was expected, see the files in '%s'" % dir)
+
+ # Check the created list
+ expected_list_file = os.path.join(ROOT_PATH, 'create_dict_test', 'expected_list.txt')
+ expected_list = eval(self.read_data_from_file(expected_list_file).replace('\r', ''))
+ if feat_list != expected_list:
+ dir = os.path.join(ROOT_PATH, "temp", "create_dict_test", "list")
+ self.create_dir(dir)
+ filename = os.path.join(dir, "expected.txt")
+ self.write_data_to_file(filename, self.feature_list_to_str(expected_list))
+ filename = os.path.join(dir, "actual.txt")
+ self.write_data_to_file(filename, self.feature_list_to_str(feat_list))
+ self.fail("Feature tree is not what was expected, see the files in '%s'" % dir)
+
+ def feature_tree_to_str(self, d, indent_amount=0):
+ """
+ Pretty-print a feature tree dictionary into a string.
+ """
+ INDENT_AMOUNT = 4
+ indent = indent_amount * ' '
+ temp = ['{']
+ if len(d) > 0: temp.append('\n')
+
+ indent += (INDENT_AMOUNT + indent_amount) * ' '
+
+ # Function for sorting the dict contents so that keys starting with
+ # '_' are first
+ def key_func(key_and_value):
+ key = key_and_value[0]
+ if key.startswith('_'): return '\x00' + key
+ else: return key
+
+ for key, value in sorted(d.items(), key=key_func):
+ temp.append(indent)
+ if isinstance(value, dict):
+ temp.append("%r: %s," % (key, self.feature_tree_to_str(value, indent_amount + INDENT_AMOUNT)))
+ else:
+ temp.append("%r: %r," % (key, value))
+ temp.append('\n')
+
+ if len(d) > 0: temp.append(indent)
+ temp.append('}')
+ return ''.join(temp)
+
+ def feature_list_to_str(self, lst):
+ """
+ Pretty-print a feature list into a string.
+ """
+ temp = ['[\n']
+ for item in lst:
+ if isinstance(item, dict): temp.append(self.feature_tree_to_str(item))
+ else: temp.append(repr(item))
+ temp.append(',\n')
+ temp.append(']')
+ return ''.join(temp)
+
+
+ def test_utf_bom_support(self):
+ OUTPUT_DIR = os.path.join(ROOT_PATH, 'temp/utf_bom_test')
+ self.recreate_dir(OUTPUT_DIR)
+ impl = self.load_impl('Layer1/implml/utf_bom_test.templateml')
+ impl.set_output_root(OUTPUT_DIR)
+ impl.generate()
+
+ def check(file, contents):
+ FILE = os.path.join(OUTPUT_DIR, file)
+ self.assert_file_content_equals(FILE, contents)
+
+ h = hex_to_bindata
+
+ # The all-around default should be UTF-8 without BOM
+ check('default.txt', h('31 30 30 E282AC'))
+
+ check('iso_8859_15_default.txt', h('31 30 30 A4'))
+ check('utf8_default.txt', h('31 30 30 E282AC'))
+ check('utf16be_default.txt', h('0031 0030 0030 20AC'))
+ check('utf16le_default.txt', h('3100 3000 3000 AC20'))
+
+ check('iso_8859_15_no_bom.txt', h('31 30 30 A4'))
+ check('utf8_no_bom.txt', h('31 30 30 E282AC'))
+ check('utf16be_no_bom.txt', h('0031 0030 0030 20AC'))
+ check('utf16le_no_bom.txt', h('3100 3000 3000 AC20'))
+
+ check('iso_8859_15_with_bom.txt', h('31 30 30 A4'))
+ check('utf8_with_bom.txt', h('EFBBBF 31 30 30 E282AC'))
+ check('utf16be_with_bom.txt', h('FEFF 0031 0030 0030 20AC'))
+ check('utf16le_with_bom.txt', h('FFFE 3100 3000 3000 AC20'))
+
+ if sys.byteorder == 'little':
+ check('utf16_default.txt', h('FFFE 3100 3000 3000 AC20'))
+ check('utf16_no_bom.txt', h('3100 3000 3000 AC20'))
+ check('utf16_with_bom.txt', h('FFFE 3100 3000 3000 AC20'))
+ else:
+ check('utf16_default.txt', h('FEFF 0031 0030 0030 20AC'))
+ check('utf16_no_bom.txt', h('0031 0030 0030 20AC'))
+ check('utf16_with_bom.txt', h('FEFF 0031 0030 0030 20AC'))
+
+ def test_invalid_encoding(self):
+ DATA = """<?xml version="1.0" encoding="UTF-8"?>
+ <templateml xmlns=\"http://www.s60.com/xml/templateml/1\">
+ <output file="test.txt" encoding="foocode">foo</output>
+ </templateml>"""
+ reader = templatemlplugin.TemplatemlImplReader()
+ self.assertRaises(exceptions.ParseError, reader.fromstring, DATA)
+
+
+class TestExtractRefsFromTemplate(unittest.TestCase):
+ def test_extract_refs_from_template(self):
+ def t(data, expected_refs):
+ actual_refs = templatemlplugin.TemplatemlImpl._extract_refs_from_template(data)
+ self.assertEquals(expected_refs, actual_refs)
+
+ t("some text {{ feat_tree.Foo }} more text",
+ ['Foo'])
+ t("some text {{ feat_tree.Foo.Bar }} more text",
+ ['Foo.Bar'])
+ t("some text {{feat_tree.Foo.Bar}} more text",
+ ['Foo.Bar'])
+ t("some text {{ feat_tree.Foo.Bar.Baz }} more text",
+ ['Foo.Bar.Baz'])
+ t("some text {{ feat_tree.Foo.Bar.Baz._value }} more text",
+ ['Foo.Bar.Baz'])
+ t(u"some text {{ feat_tree.ударения.ελληνικά }} more text",
+ [u'ударения.ελληνικά'])
+ t(u"some text {{ feat_tree.ударения.ελληνικά._value }} more text",
+ [u'ударения.ελληνικά'])
+ t("some text {{ feat_tree.MyFeature.MySetting|some_filter }} more text",
+ ['MyFeature.MySetting'])
+ t(u"some text {{ feat_tree.MyFeature.MySetting|some_filter }} more text",
+ ['MyFeature.MySetting'])
+ t("some text {{ feat_tree.MyFeature.MySetting | some_filter }} more text",
+ ['MyFeature.MySetting'])
+ t("some text {{ feat_tree.MyFeature.MySetting._value|some_filter }} more text",
+ ['MyFeature.MySetting'])
+ t("some text {{ feat_tree.Xyz.Zyx._type }} more {{feat_tree.Xyz.Zyx._type}} text",
+ ['Xyz.Zyx', 'Xyz.Zyx'])
+ t("some text {% for x in feat_tree.MyFeature.MySetting._value|sort %} more text",
+ ['MyFeature.MySetting'])
+
+if __name__ == '__main__':
+ unittest.main()