diff -r 000000000000 -r 2e8eeb919028 configurationengine/source/plugins/common/ConeTemplatePlugin/templatemlplugin/tests/unittest_templatemlplugin.py
--- /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()