|
0
|
1 |
# *-* coding: utf-8 *-*
|
|
|
2 |
#
|
|
|
3 |
# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
|
4 |
# All rights reserved.
|
|
|
5 |
# This component and the accompanying materials are made available
|
|
|
6 |
# under the terms of "Eclipse Public License v1.0"
|
|
|
7 |
# which accompanies this distribution, and is available
|
|
|
8 |
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
|
9 |
#
|
|
|
10 |
# Initial Contributors:
|
|
|
11 |
# Nokia Corporation - initial contribution.
|
|
|
12 |
#
|
|
|
13 |
# Contributors:
|
|
|
14 |
#
|
|
|
15 |
# Description:
|
|
|
16 |
#
|
|
|
17 |
|
|
3
|
18 |
import unittest, os, sys
|
|
|
19 |
import logging
|
|
0
|
20 |
|
|
|
21 |
try:
|
|
|
22 |
from cElementTree import ElementTree, ElementInclude
|
|
|
23 |
except ImportError:
|
|
|
24 |
try:
|
|
|
25 |
from elementtree import ElementTree, ElementInclude
|
|
|
26 |
except ImportError:
|
|
|
27 |
try:
|
|
|
28 |
from xml.etree import cElementTree as ElementTree
|
|
|
29 |
except ImportError:
|
|
|
30 |
from xml.etree import ElementTree
|
|
|
31 |
|
|
|
32 |
from templatemlplugin import templatemlplugin
|
|
|
33 |
from testautomation.base_testcase import BaseTestCase
|
|
|
34 |
from testautomation.utils import hex_to_bindata
|
|
|
35 |
|
|
|
36 |
from cone.public import exceptions,plugin,api,utils
|
|
|
37 |
from cone.storage import filestorage
|
|
|
38 |
from cone.confml import implml
|
|
|
39 |
|
|
|
40 |
# Hardcoded value of testdata folder that must be under the current working dir
|
|
|
41 |
ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
|
|
|
42 |
testdata = os.path.join(ROOT_PATH,'project')
|
|
|
43 |
|
|
|
44 |
TEMPML_DOC1 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \
|
|
|
45 |
"<templateml xmlns=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \
|
|
|
46 |
"<desc>Desc</desc>" \
|
|
|
47 |
"<output file=\"test.txt\" encoding=\"UTF-16\">" \
|
|
|
48 |
"<template extension=\"foo/foobar:MyClass\">ABCDF</template>" \
|
|
|
49 |
"</output>" \
|
|
|
50 |
"<filter name=\"test_filter\">lambda a,b: a+b</filter>" \
|
|
|
51 |
"</templateml>"
|
|
|
52 |
|
|
|
53 |
TEMPML_DOC2 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \
|
|
|
54 |
"<templateml xmlns=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \
|
|
|
55 |
"<desc>Desc</desc>" \
|
|
|
56 |
"<output file=\"test.txt\" encoding=\"UTF-16\">" \
|
|
|
57 |
"<template extension=\"foo/foobar:MyClass\"><xi:include href=\"project/templates/template.xml\" parse=\"xml\"/></template>" \
|
|
|
58 |
"</output>" \
|
|
|
59 |
"<filter name=\"test_filter\">lambda a,b: a+b</filter>" \
|
|
|
60 |
"</templateml>"
|
|
|
61 |
|
|
|
62 |
TEMPML_DOC3 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \
|
|
|
63 |
"<templateml xmlns=\"http://www.s60.com/xml/templateml/1\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">" \
|
|
|
64 |
"<desc>Desc</desc>" \
|
|
|
65 |
"<output file=\"test.txt\" encoding=\"UTF-16\">" \
|
|
|
66 |
"<template extension=\"foo/foobar:MyClass\"><xi:include href=\"project/templates/template.xml\" parse=\"xml\"/></template>" \
|
|
|
67 |
"</output>" \
|
|
|
68 |
"<filter name=\"test_filter\">lambda a,b: a+b</filter>" \
|
|
|
69 |
"</templateml>"
|
|
|
70 |
|
|
|
71 |
TEMPML_DOC4 = "<?xml version=\"1.0\" encoding=\"ascii\"?> " \
|
|
|
72 |
"<templateml xmlns=\"http://www.s60.com/xml/templateml/1\">" \
|
|
|
73 |
"<output file=\"test.txt\" encoding=\"ascii\">" \
|
|
|
74 |
"<template file=\"../../templates/template.xml\"/>" \
|
|
|
75 |
"</output>" \
|
|
|
76 |
"<filter name=\"test_filter\" file=\"../../filter/filter.py\"/>" \
|
|
|
77 |
"</templateml>"
|
|
|
78 |
|
|
3
|
79 |
TEMPML1 = "<ns0:output encoding=\"ASCII\" file=\"test.txt\" xmlns:ns0=\"http://www.s60.com/xml/templateml/1\" newline=\"win\">" \
|
|
0
|
80 |
"<ns0:template extension=\"foo/foobar:MyClass\">ABCDF</ns0:template>" \
|
|
|
81 |
"</ns0:output>"
|
|
|
82 |
|
|
3
|
83 |
TEMPML1_LINUX = "<ns0:output encoding=\"ASCII\" file=\"test.txt\" xmlns:ns0=\"http://www.s60.com/xml/templateml/1\">" \
|
|
|
84 |
"<ns0:template extension=\"foo/foobar:MyClass\" newline=\"unix\">ABCDF</ns0:template>" \
|
|
|
85 |
"</ns0:output>"
|
|
|
86 |
|
|
0
|
87 |
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\">" \
|
|
|
88 |
"<ns0:template extension=\"foo/foobar:MyClass\">" \
|
|
|
89 |
"include AABBCC" \
|
|
|
90 |
"</ns0:template>" \
|
|
|
91 |
"</ns0:output>"
|
|
|
92 |
|
|
|
93 |
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\">" \
|
|
|
94 |
"<ns0:template extension=\"foo/foobar:MyClass\">" \
|
|
|
95 |
"include AABBCC" \
|
|
|
96 |
"</ns0:template>" \
|
|
|
97 |
"<filter name=\"test_filter\">lambda a,b: a+b</filter>" \
|
|
|
98 |
"</ns0:output>"
|
|
|
99 |
|
|
|
100 |
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\">" \
|
|
|
101 |
"<ns0:template file=\"../../templates/template.xml\"/>" \
|
|
|
102 |
"<filter name=\"test_filter\" file=\"../../filter/filter.py\"/>" \
|
|
|
103 |
"</ns0:output>"
|
|
|
104 |
|
|
|
105 |
|
|
|
106 |
def impl_from_resource(resource_ref, configuration):
|
|
3
|
107 |
impls = plugin.ImplFactory.get_impls_from_file(resource_ref, configuration)
|
|
|
108 |
assert len(impls) == 1
|
|
|
109 |
return impls[0]
|
|
0
|
110 |
|
|
|
111 |
class TestTemplatemlPlugin(BaseTestCase):
|
|
|
112 |
def setUp(self):
|
|
|
113 |
self.curdir = os.getcwd()
|
|
|
114 |
self.output = os.path.join(ROOT_PATH, 'output')
|
|
|
115 |
os.chdir(os.path.join(ROOT_PATH))
|
|
|
116 |
|
|
|
117 |
def tearDown(self):
|
|
|
118 |
os.chdir(self.curdir)
|
|
|
119 |
|
|
|
120 |
def load_config(self, config):
|
|
|
121 |
fs = filestorage.FileStorage(testdata)
|
|
|
122 |
p = api.Project(fs)
|
|
|
123 |
return p.get_configuration(config)
|
|
|
124 |
|
|
|
125 |
def load_impl(self, resource_ref, config='root1.confml'):
|
|
|
126 |
configuration = self.load_config(config)
|
|
|
127 |
pattern = '^' + resource_ref.replace('.', r'\.') + '$'
|
|
|
128 |
impls = plugin.get_impl_set(configuration, pattern)
|
|
|
129 |
impls.output = self.output
|
|
|
130 |
impl_list = impls.get_implementations_by_file(resource_ref)
|
|
|
131 |
self.assertEquals(1, len(impl_list))
|
|
3
|
132 |
return (configuration,impl_list[0])
|
|
0
|
133 |
|
|
|
134 |
def test_parse_desc(self):
|
|
3
|
135 |
(config,impl) = self.load_impl('Layer1/implml/file1.templateml')
|
|
0
|
136 |
self.assertEqual("Description field text", impl.reader.desc)
|
|
|
137 |
|
|
|
138 |
def test_parse_output_with_file_ref(self):
|
|
3
|
139 |
(config,impl) = self.load_impl('Layer1/implml/output_with_ref.templateml')
|
|
|
140 |
self.assertEquals(impl.list_output_files(), [os.path.normpath('confmlref_filename.txt')])
|
|
0
|
141 |
|
|
|
142 |
def test_parse_outputs(self):
|
|
3
|
143 |
(config,impl) = self.load_impl('Layer1/implml/file1.templateml')
|
|
0
|
144 |
outputs = []
|
|
|
145 |
output1 = templatemlplugin.OutputFile()
|
|
|
146 |
output1.set_encoding("UTF-16")
|
|
|
147 |
output1.set_filename("test.txt")
|
|
|
148 |
output1.set_path('')
|
|
3
|
149 |
output1.set_newline('unix')
|
|
0
|
150 |
temp1 = templatemlplugin.TempFile()
|
|
|
151 |
temp1.set_template(u'ABC kissa k\xe4velee')
|
|
|
152 |
output1.set_template(temp1)
|
|
|
153 |
outputs.append(output1)
|
|
|
154 |
|
|
|
155 |
output2 = templatemlplugin.OutputFile()
|
|
|
156 |
output2.set_encoding("UTF-16")
|
|
|
157 |
output2.set_filename("test2.txt")
|
|
|
158 |
output2.set_path("output")
|
|
3
|
159 |
output2.set_newline('win')
|
|
0
|
160 |
temp2 = templatemlplugin.TempFile()
|
|
|
161 |
temp2.set_template('AABBCC')
|
|
|
162 |
output2.set_template(temp2)
|
|
|
163 |
outputs.append(output2)
|
|
|
164 |
|
|
|
165 |
output3 = templatemlplugin.OutputFile()
|
|
|
166 |
output3.set_encoding("UTF-8")
|
|
|
167 |
output3.set_filename("test3.txt")
|
|
|
168 |
output3.set_path('')
|
|
|
169 |
temp3 = templatemlplugin.TempFile()
|
|
|
170 |
temp3.set_template(u'ABC kissa k\xe4velee')
|
|
|
171 |
output3.set_template(temp3)
|
|
|
172 |
|
|
|
173 |
outputs.append(output3)
|
|
|
174 |
|
|
|
175 |
self.assertNotEqual(impl.reader.outputs, None)
|
|
|
176 |
self.assertEqual(outputs[0].encoding, impl.reader.outputs[0].encoding)
|
|
|
177 |
self.assertEqual(outputs[0].filename, impl.reader.outputs[0].filename)
|
|
|
178 |
self.assertEqual(outputs[0].path, impl.reader.outputs[0].path)
|
|
3
|
179 |
self.assertEqual(outputs[0].newline, impl.reader.outputs[0].newline)
|
|
0
|
180 |
self.assertEqual(outputs[0].template.template, impl.reader.outputs[0].template.template)
|
|
|
181 |
self.assertEqual(outputs[0].template.extensions, impl.reader.outputs[0].template.extensions)
|
|
|
182 |
self.assertEqual(outputs[0].template.filters, impl.reader.outputs[0].template.filters)
|
|
|
183 |
self.assertEqual(outputs[0].template, impl.reader.outputs[0].template)
|
|
|
184 |
self.assertEqual(outputs[0], impl.reader.outputs[0])
|
|
|
185 |
|
|
|
186 |
self.assertEqual(outputs[1].encoding, impl.reader.outputs[1].encoding)
|
|
|
187 |
self.assertEqual(outputs[1].filename, impl.reader.outputs[1].filename)
|
|
|
188 |
self.assertEqual(outputs[1].path, impl.reader.outputs[1].path)
|
|
3
|
189 |
self.assertEqual(outputs[1].newline, impl.reader.outputs[1].newline)
|
|
0
|
190 |
#self.assertEqual(outputs[1].template.template, impl.reader.outputs[1].template.template)
|
|
|
191 |
self.assertEqual(outputs[1].template.extensions, impl.reader.outputs[1].template.extensions)
|
|
|
192 |
self.assertEqual(outputs[1].template.filters, impl.reader.outputs[1].template.filters)
|
|
|
193 |
#self.assertEqual(outputs[1].template, impl.reader.outputs[1].template)
|
|
|
194 |
#self.assertEqual(outputs[1], impl.reader.outputs[1])
|
|
|
195 |
|
|
|
196 |
self.assertEqual(outputs[2].encoding, impl.reader.outputs[2].encoding)
|
|
|
197 |
self.assertEqual(outputs[2].filename, impl.reader.outputs[2].filename)
|
|
|
198 |
self.assertEqual(outputs[2].path, impl.reader.outputs[2].path)
|
|
|
199 |
#self.assertEqual(outputs[2].template.template, impl.reader.outputs[2].template.template)
|
|
|
200 |
self.assertEqual(outputs[2].template.extensions, impl.reader.outputs[2].template.extensions)
|
|
|
201 |
self.assertEqual(outputs[2].template.filters, impl.reader.outputs[2].template.filters)
|
|
|
202 |
#self.assertEqual(outputs[2].template, impl.reader.outputs[2].template)
|
|
|
203 |
|
|
|
204 |
#self.assertEqual(outputs[2], impl.reader.outputs[2])
|
|
|
205 |
|
|
|
206 |
def test_parse_outputfile(self):
|
|
|
207 |
output1 = templatemlplugin.OutputFile()
|
|
|
208 |
output2 = templatemlplugin.OutputFile()
|
|
|
209 |
|
|
|
210 |
self.assertEqual(output1, output2)
|
|
|
211 |
self.assertEqual(output1.encoding, output2.encoding)
|
|
|
212 |
self.assertEqual(output1.path, output2.path)
|
|
|
213 |
self.assertEqual(output1.filename, output2.filename)
|
|
|
214 |
|
|
|
215 |
output1.set_encoding("utf-8")
|
|
|
216 |
output2.set_encoding("utf-8")
|
|
|
217 |
|
|
|
218 |
self.assertEqual(output1, output2)# utf-8, utf-8
|
|
|
219 |
|
|
|
220 |
output1.set_encoding("utf-16")
|
|
|
221 |
|
|
|
222 |
self.assertNotEqual(output1, output2)#utf-16, utf-8
|
|
|
223 |
|
|
|
224 |
output2.set_encoding("utf-16")
|
|
|
225 |
|
|
|
226 |
self.assertEqual(output1, output2)#utf-16, utf-16
|
|
|
227 |
|
|
|
228 |
def test_parse_template(self):
|
|
|
229 |
reader = templatemlplugin.TemplatemlImplReader()
|
|
|
230 |
reader.fromstring(TEMPML_DOC1)
|
|
|
231 |
|
|
|
232 |
temp1 = reader.parse_template(ElementTree.fromstring(TEMPML1))
|
|
|
233 |
temp2 = templatemlplugin.TempFile()
|
|
|
234 |
temp2.set_template("ABCDF")
|
|
|
235 |
|
|
|
236 |
self.assertEqual(temp1.template, temp2.template)
|
|
|
237 |
self.assertEqual(temp1.extensions, temp2.extensions)
|
|
|
238 |
self.assertEqual(temp1.filters, temp2.filters)
|
|
|
239 |
self.assertEqual(temp1, temp2)
|
|
|
240 |
|
|
|
241 |
def test_parse_template_from_xinclude(self):
|
|
|
242 |
try:
|
|
|
243 |
reader = templatemlplugin.TemplatemlImplReader()
|
|
|
244 |
reader.fromstring(TEMPML_DOC2)
|
|
|
245 |
|
|
|
246 |
temp1 = reader.parse_template(ElementTree.fromstring(TEMPML2))
|
|
|
247 |
temp2 = templatemlplugin.TempFile()
|
|
|
248 |
temp2.set_template("include AABBCC")
|
|
|
249 |
except exceptions.ParseError, e:
|
|
|
250 |
self.fail("Known bug: ticket #2007")
|
|
|
251 |
|
|
|
252 |
self.assertEqual(temp1.template, temp2.template)
|
|
|
253 |
self.assertEqual(temp1.extensions, temp2.extensions)
|
|
|
254 |
self.assertEqual(temp1.filters, temp2.filters)
|
|
|
255 |
self.assertEqual(temp1, temp2)
|
|
|
256 |
|
|
|
257 |
def test_parse_template_filter(self):
|
|
|
258 |
try:
|
|
|
259 |
reader = templatemlplugin.TemplatemlImplReader()
|
|
|
260 |
reader.fromstring(TEMPML_DOC3)
|
|
|
261 |
filters1 = reader.filters
|
|
|
262 |
filter2 = templatemlplugin.Filter()
|
|
|
263 |
filter2.set_code("lambda a,b: a+b")
|
|
|
264 |
filter2.set_name("test_filter")
|
|
|
265 |
except exceptions.ParseError, e:
|
|
|
266 |
self.fail( "Known bug: ticket #2007")
|
|
|
267 |
self.assertEqual(filters1[0].name, filter2.name)
|
|
|
268 |
self.assertEqual(filters1[0].code, filter2.code)
|
|
|
269 |
self.assertEqual(filters1[0], filter2)
|
|
|
270 |
|
|
3
|
271 |
def test_parse_template_filter_2(self):
|
|
0
|
272 |
class DummyConfiguration(object):
|
|
|
273 |
def get_resource(self, ref):
|
|
|
274 |
class DummyResource(object):
|
|
|
275 |
def read(self): return ''
|
|
|
276 |
def close(self): return None
|
|
|
277 |
return DummyResource()
|
|
|
278 |
def get_default_view(self): return None
|
|
|
279 |
reader = templatemlplugin.TemplatemlImplReader('foo/implml/bar.implml', DummyConfiguration())
|
|
|
280 |
reader.fromstring(TEMPML_DOC4)
|
|
|
281 |
|
|
|
282 |
filters1 = reader.filters
|
|
|
283 |
filter2 = templatemlplugin.Filter()
|
|
|
284 |
filter2.set_code(None)
|
|
|
285 |
filter2.set_name("test_filter")
|
|
|
286 |
filter2.set_path("../../filter/filter.py")
|
|
|
287 |
temp1 = reader.parse_template(ElementTree.fromstring(TEMPML4))
|
|
|
288 |
temp2 = templatemlplugin.TempFile()
|
|
|
289 |
temp2.set_template('')
|
|
|
290 |
temp2.set_path('')
|
|
|
291 |
|
|
|
292 |
self.assertEqual(filters1[0].name, filter2.name)
|
|
|
293 |
self.assertEqual(filters1[0].code, filter2.code)
|
|
|
294 |
self.assertEqual(filters1[0].path, filter2.path)
|
|
|
295 |
self.assertEqual(filters1[0], filter2)
|
|
|
296 |
self.assertEqual(temp1.template, temp2.template)
|
|
|
297 |
self.assertEqual(temp1.extensions, temp2.extensions)
|
|
|
298 |
self.assertEqual(temp1.filters, temp2.filters)
|
|
|
299 |
self.assertEqual(temp1, temp2)
|
|
|
300 |
|
|
|
301 |
def test_simple_generate_prj(self):
|
|
|
302 |
|
|
|
303 |
self.remove_if_exists(os.path.normpath("output/output/test.txt"))
|
|
|
304 |
|
|
3
|
305 |
(config,impl) = self.load_impl('Layer1/implml/file2.templateml')
|
|
0
|
306 |
#impl.context = {'name' : 'some value'}
|
|
3
|
307 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
308 |
impl.generate(gc)
|
|
0
|
309 |
|
|
|
310 |
self.assertTrue(os.path.exists(os.path.normpath("output/output/test.txt")))
|
|
|
311 |
result_file = None
|
|
|
312 |
try:
|
|
|
313 |
result_file = open(os.path.normpath("output/output/test.txt"))
|
|
|
314 |
for line in result_file:
|
|
|
315 |
self.assertTrue(line == "include AABBCC")
|
|
|
316 |
finally:
|
|
|
317 |
if result_file != None: result_file.close()
|
|
|
318 |
|
|
3
|
319 |
def test_simple_generate_newline(self):
|
|
|
320 |
|
|
|
321 |
self.remove_if_exists(os.path.normpath("output/output/test_newline_win.txt"))
|
|
|
322 |
self.remove_if_exists(os.path.normpath("output/output/test_newline_unix.txt"))
|
|
|
323 |
|
|
|
324 |
(config,impl) = self.load_impl('Layer1/implml/newline.templateml')
|
|
|
325 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
326 |
impl.generate(gc)
|
|
|
327 |
|
|
|
328 |
self.assertTrue(os.path.exists(os.path.normpath("output/output/test_newline_win.txt")))
|
|
|
329 |
self.assertTrue(os.path.exists(os.path.normpath("output/output/test_newline_unix.txt")))
|
|
|
330 |
|
|
|
331 |
result_file_win = None
|
|
|
332 |
try:
|
|
|
333 |
result_file_win = open(os.path.normpath("output/output/test_newline_win.txt"),'rb')
|
|
|
334 |
line = result_file_win.read()
|
|
|
335 |
self.assertEquals(line, "line1\r\nline2")
|
|
|
336 |
finally:
|
|
|
337 |
if result_file_win != None: result_file_win.close()
|
|
|
338 |
|
|
|
339 |
result_file_unix = None
|
|
|
340 |
try:
|
|
|
341 |
result_file_unix = open(os.path.normpath("output/output/test_newline_unix.txt"), 'rb')
|
|
|
342 |
line = result_file_unix.read()
|
|
|
343 |
self.assertEquals(line, "line1\nline2")
|
|
|
344 |
finally:
|
|
|
345 |
if result_file_unix != None: result_file_unix.close()
|
|
|
346 |
|
|
0
|
347 |
def test_simple_generate_prj3(self):
|
|
|
348 |
|
|
|
349 |
self.remove_if_exists(os.path.normpath("output/output/test3.txt"))
|
|
|
350 |
|
|
3
|
351 |
(config,impl) = self.load_impl('Layer1/implml/file3.templateml')
|
|
|
352 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
353 |
impl.generate(gc)
|
|
0
|
354 |
|
|
|
355 |
self.assertTrue(os.path.exists(os.path.normpath("output/output/test3.txt")))
|
|
|
356 |
result_file = None
|
|
|
357 |
try:
|
|
|
358 |
result_file = open(os.path.normpath("output/output/test3.txt"))
|
|
|
359 |
for line in result_file:
|
|
|
360 |
self.assertTrue(line == "'Hello John Doe!'")
|
|
|
361 |
finally:
|
|
|
362 |
if result_file != None: result_file.close()
|
|
|
363 |
|
|
3
|
364 |
|
|
0
|
365 |
def test_simple_generate_prj4_with_filters(self):
|
|
|
366 |
|
|
|
367 |
self.remove_if_exists(os.path.normpath("output/output/test4a.txt"))
|
|
|
368 |
self.remove_if_exists(os.path.normpath("output/output/test4b.txt"))
|
|
|
369 |
self.remove_if_exists(os.path.normpath("output/output/test4c.txt"))
|
|
|
370 |
self.remove_if_exists(os.path.normpath("output/output/test4d.txt"))
|
|
|
371 |
|
|
3
|
372 |
(config,impl) = self.load_impl('Layer1/implml/file4.templateml')
|
|
0
|
373 |
#impl.context = {'name' : 'John Doe'}
|
|
3
|
374 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
375 |
impl.generate(gc)
|
|
0
|
376 |
|
|
|
377 |
self.assertTrue(os.path.exists(os.path.normpath("output/output/test4a.txt")))
|
|
|
378 |
self.assertTrue(os.path.exists(os.path.normpath("output/output/test4b.txt")))
|
|
|
379 |
self.assertTrue(os.path.exists(os.path.normpath("output/output/test4c.txt")))
|
|
|
380 |
self.assertTrue(os.path.exists(os.path.normpath("output/output/test4d.txt")))
|
|
|
381 |
|
|
|
382 |
result_file1 = None
|
|
|
383 |
result_file2 = None
|
|
|
384 |
result_file3 = None
|
|
|
385 |
result_file4 = None
|
|
|
386 |
|
|
|
387 |
try:
|
|
|
388 |
result_file1 = open(os.path.normpath("output/output/test4a.txt"))
|
|
|
389 |
result_file2 = open(os.path.normpath("output/output/test4b.txt"))
|
|
|
390 |
result_file3 = open(os.path.normpath("output/output/test4c.txt"))
|
|
|
391 |
result_file4 = open(os.path.normpath("output/output/test4d.txt"))
|
|
|
392 |
|
|
|
393 |
if result_file1 != None:
|
|
|
394 |
for line in result_file1:
|
|
|
395 |
self.assertTrue(line == "'Hello John Doe!'")
|
|
|
396 |
else:
|
|
|
397 |
self.fail("No result file found: output/output/test4a.txt")
|
|
|
398 |
|
|
|
399 |
if result_file2 != None:
|
|
|
400 |
for line in result_file2:
|
|
|
401 |
self.assertTrue(line == "'Hello John Doe again!'")
|
|
|
402 |
else:
|
|
|
403 |
self.fail("No result file found: output/output/test4b.txt")
|
|
|
404 |
|
|
|
405 |
if result_file3 != None:
|
|
|
406 |
for line in result_file3:
|
|
|
407 |
self.assertTrue(line == "2+3=5")
|
|
|
408 |
else:
|
|
|
409 |
self.fail("No result file found: output/output/test4c.txt")
|
|
|
410 |
|
|
|
411 |
if result_file4 != None:
|
|
|
412 |
for line in result_file4:
|
|
|
413 |
self.assertTrue(line == "--6")
|
|
|
414 |
else:
|
|
|
415 |
self.fail("No result file found: output/output/test4d.txt")
|
|
|
416 |
|
|
|
417 |
finally:
|
|
|
418 |
if result_file1 != None: result_file1.close()
|
|
|
419 |
if result_file2 != None: result_file2.close()
|
|
|
420 |
if result_file3 != None: result_file3.close()
|
|
|
421 |
if result_file4 != None: result_file4.close()
|
|
|
422 |
|
|
|
423 |
def test_simple_generate_prj_extfiles_with_filters(self):
|
|
|
424 |
|
|
|
425 |
self.remove_if_exists(os.path.normpath("output/output/test_ext_temp_file.txt"))
|
|
|
426 |
|
|
3
|
427 |
(config,impl) = self.load_impl('Layer1/implml/external_tempfile.templateml')
|
|
|
428 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
429 |
impl.generate(gc)
|
|
0
|
430 |
|
|
|
431 |
self.assertTrue(os.path.exists(os.path.normpath("output/output/test_ext_temp_file.txt")))
|
|
|
432 |
|
|
|
433 |
result_file1 = None
|
|
|
434 |
|
|
|
435 |
try:
|
|
|
436 |
result_file1 = open(os.path.normpath("output/output/test_ext_temp_file.txt"))
|
|
|
437 |
lines = 0
|
|
|
438 |
|
|
|
439 |
if result_file1 != None:
|
|
|
440 |
for line in result_file1:
|
|
|
441 |
self.assertTrue(line == "2+3=-1")
|
|
|
442 |
lines += 1
|
|
|
443 |
else:
|
|
|
444 |
self.fail("No result file found: output/output/test_ext_temp_file.txt")
|
|
|
445 |
|
|
|
446 |
self.assertTrue(lines == 1, "Wrong number of lines generated.")
|
|
|
447 |
|
|
|
448 |
finally:
|
|
|
449 |
if result_file1 != None: result_file1.close()
|
|
|
450 |
|
|
4
|
451 |
def test_simple_generate_prj7_with_funcs_as_filters(self):
|
|
|
452 |
|
|
|
453 |
self.remove_if_exists(os.path.normpath("output/output/test7a.txt"))
|
|
|
454 |
self.remove_if_exists(os.path.normpath("output/output/test7b.txt"))
|
|
|
455 |
self.remove_if_exists(os.path.normpath("output/output/test7c.txt"))
|
|
|
456 |
|
|
|
457 |
(config,impl) = self.load_impl('Layer1/implml/file7.templateml')
|
|
|
458 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
459 |
impl.generate(gc)
|
|
|
460 |
|
|
|
461 |
self.assert_exists_and_contains_something(os.path.normpath("output/output/test7a.txt"))
|
|
|
462 |
self.assert_exists_and_contains_something(os.path.normpath("output/output/test7b.txt"))
|
|
|
463 |
self.assert_exists_and_contains_something(os.path.normpath("output/output/test7c.txt"))
|
|
|
464 |
|
|
|
465 |
result_file1 = None
|
|
|
466 |
result_file2 = None
|
|
|
467 |
result_file3 = None
|
|
|
468 |
|
|
|
469 |
try:
|
|
|
470 |
result_file1 = open(os.path.normpath("output/output/test7a.txt"))
|
|
|
471 |
result_file2 = open(os.path.normpath("output/output/test7b.txt"))
|
|
|
472 |
result_file3 = open(os.path.normpath("output/output/test7c.txt"))
|
|
|
473 |
|
|
|
474 |
if result_file1 != None:
|
|
|
475 |
for line in result_file1:
|
|
|
476 |
self.assertTrue(line == "3 + 4 = 7")
|
|
|
477 |
else:
|
|
|
478 |
self.fail("No result file found: output/output/test7a.txt")
|
|
|
479 |
|
|
|
480 |
if result_file2 != None:
|
|
|
481 |
for line in result_file2:
|
|
|
482 |
self.assertTrue(line == "3 ** 4 = 81")
|
|
|
483 |
else:
|
|
|
484 |
self.fail("No result file found: output/output/test7b.txt")
|
|
|
485 |
|
|
|
486 |
if result_file3 != None:
|
|
|
487 |
for line in result_file3:
|
|
|
488 |
self.assertTrue((line.strip() == "2!=3") or (line.strip() == "5=5"))
|
|
|
489 |
else:
|
|
|
490 |
self.fail("No result file found: output/output/test7c.txt")
|
|
|
491 |
finally:
|
|
|
492 |
if result_file1 != None: result_file1.close()
|
|
|
493 |
if result_file2 != None: result_file2.close()
|
|
|
494 |
if result_file2 != None: result_file3.close()
|
|
|
495 |
|
|
|
496 |
|
|
|
497 |
def test_simple_generate_prj8_with_funcs_as_filters_under_output_elems(self):
|
|
|
498 |
|
|
|
499 |
self.remove_if_exists(os.path.normpath("output/output/test8a.txt"))
|
|
|
500 |
self.remove_if_exists(os.path.normpath("output/output/test8b.txt"))
|
|
|
501 |
|
|
|
502 |
(config,impl) = self.load_impl('Layer1/implml/file8.templateml')
|
|
|
503 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
504 |
impl.generate(gc)
|
|
|
505 |
|
|
|
506 |
self.assert_exists_and_contains_something(os.path.normpath("output/output/test8a.txt"))
|
|
|
507 |
self.assert_exists_and_contains_something(os.path.normpath("output/output/test8b.txt"))
|
|
|
508 |
#self.assertTrue(os.path.exists(os.path.normpath("output/output/test8a.txt")))
|
|
|
509 |
#self.assertTrue(os.path.exists(os.path.normpath("output/output/test8b.txt")))
|
|
|
510 |
|
|
|
511 |
result_file1 = None
|
|
|
512 |
result_file2 = None
|
|
|
513 |
|
|
|
514 |
try:
|
|
|
515 |
result_file1 = open(os.path.normpath("output/output/test8a.txt"))
|
|
|
516 |
result_file2 = open(os.path.normpath("output/output/test8b.txt"))
|
|
|
517 |
|
|
|
518 |
if result_file1 != None:
|
|
|
519 |
for line in result_file1:
|
|
|
520 |
self.assertTrue(line == "3 + 4 = 7")
|
|
|
521 |
else:
|
|
|
522 |
self.fail("No result file found: output/output/test8a.txt")
|
|
|
523 |
|
|
|
524 |
if result_file2 != None:
|
|
|
525 |
for line in result_file2:
|
|
|
526 |
self.assertTrue(line == "3 ** 4 = 81")
|
|
|
527 |
else:
|
|
|
528 |
self.fail("No result file found: output/output/test8b.txt")
|
|
|
529 |
|
|
|
530 |
finally:
|
|
|
531 |
if result_file1 != None: result_file1.close()
|
|
|
532 |
if result_file2 != None: result_file2.close()
|
|
|
533 |
|
|
|
534 |
def test_filters_in_output_not_visible_to_other_outputs(self):
|
|
|
535 |
self.remove_if_exists(os.path.normpath("output/output/test9a.txt"))
|
|
|
536 |
self.remove_if_exists(os.path.normpath("output/output/test9b.txt"))
|
|
|
537 |
(config,impl) = self.load_impl('Layer1/implml/file9.templateml')
|
|
|
538 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
539 |
impl.generate(gc)
|
|
|
540 |
self.assert_exists_and_contains_something(os.path.normpath("output/output/test9a.txt"))
|
|
|
541 |
result_file1 = None
|
|
|
542 |
try:
|
|
|
543 |
result_file1 = open(os.path.normpath("output/output/test9a.txt"))
|
|
|
544 |
|
|
|
545 |
if result_file1 != None:
|
|
|
546 |
for line in result_file1:
|
|
|
547 |
self.assertTrue(line == "3 + 4 = 7")
|
|
|
548 |
else:
|
|
|
549 |
self.fail("No result file found: output/output/test9a.txt")
|
|
|
550 |
finally:
|
|
|
551 |
if result_file1 != None: result_file1.close()
|
|
|
552 |
|
|
|
553 |
# an empty file must be created
|
|
|
554 |
self.assert_file_content_equals(os.path.normpath("output/output/test9b.txt"), "", ignore_endline_style=True)
|
|
|
555 |
|
|
0
|
556 |
def test_generate_prj1(self):
|
|
|
557 |
|
|
|
558 |
self.remove_if_exists(os.path.normpath("output/output/test5a.txt"))
|
|
|
559 |
|
|
3
|
560 |
(config,impl) = self.load_impl('Layer1/implml/file5.templateml')
|
|
|
561 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
562 |
impl.generate(gc)
|
|
0
|
563 |
self.assertTrue(os.path.exists(os.path.normpath("output/output/test5a.txt")))
|
|
|
564 |
|
|
|
565 |
result_file1 = None
|
|
|
566 |
try:
|
|
|
567 |
result_file1 = open(os.path.normpath("output/output/test5a.txt"))
|
|
|
568 |
|
|
|
569 |
if result_file1 != None:
|
|
|
570 |
for line in result_file1:
|
|
|
571 |
self.assertTrue(line == "'Hello John Doe'")
|
|
|
572 |
else:
|
|
|
573 |
self.fail("No result file found: output/output/test5a.txt")
|
|
|
574 |
finally:
|
|
|
575 |
if result_file1 != None: result_file1.close()
|
|
|
576 |
|
|
|
577 |
def test_generate_access_configuration(self):
|
|
|
578 |
|
|
|
579 |
self.remove_if_exists(os.path.normpath("output/access_configuration.txt"))
|
|
|
580 |
|
|
3
|
581 |
(config,impl) = self.load_impl('Layer1/implml/access_configuration.templateml')
|
|
|
582 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
583 |
impl.generate(gc)
|
|
0
|
584 |
self.assertTrue(os.path.exists(os.path.normpath("output/access_configuration.txt")))
|
|
|
585 |
|
|
|
586 |
result_file1 = None
|
|
|
587 |
try:
|
|
|
588 |
result_file1 = open(os.path.normpath("output/access_configuration.txt"))
|
|
|
589 |
data = result_file1.read()
|
|
|
590 |
if result_file1 != None:
|
|
|
591 |
self.assertTrue(data.startswith("Configuration name: root1.confml"))
|
|
|
592 |
else:
|
|
|
593 |
self.fail("No result file found: output/access_configuration.txt")
|
|
|
594 |
finally:
|
|
|
595 |
if result_file1 != None: result_file1.close()
|
|
|
596 |
|
|
|
597 |
def test_create_context_dict1(self):
|
|
3
|
598 |
(config,impl) = self.load_impl('Layer1/implml/file6.templateml')
|
|
0
|
599 |
impl.context = impl.create_dict()
|
|
3
|
600 |
gc = plugin.GenerationContext(configuration=config)
|
|
|
601 |
impl.generate(gc)
|
|
0
|
602 |
|
|
|
603 |
def test_list_output_files(self):
|
|
3
|
604 |
(config,impl) = self.load_impl('Layer1/implml/file1.templateml')
|
|
0
|
605 |
impl.set_output_root('outdir')
|
|
|
606 |
output_files = impl.list_output_files()
|
|
|
607 |
expected = map(lambda n: os.path.normpath(n), [
|
|
|
608 |
'outdir/test.txt',
|
|
|
609 |
'outdir/output/test2.txt',
|
|
|
610 |
'outdir/test3.txt',
|
|
|
611 |
'outdir/output/test4.txt',
|
|
|
612 |
'outdir/some/test/path/test5.txt',
|
|
|
613 |
])
|
|
|
614 |
self.assertEquals(sorted(output_files), sorted(expected))
|
|
|
615 |
|
|
|
616 |
def test_has_ref(self):
|
|
3
|
617 |
(config,impl) = self.load_impl('Layer1/implml/has_ref_template_test2.templateml')
|
|
0
|
618 |
self.assertEquals(impl.has_ref('Feature1.StringSetting_not_found'), False)
|
|
|
619 |
self.assertEquals(impl.has_ref('Feature1.StringSetting1'), True)
|
|
|
620 |
self.assertEquals(impl.has_ref('Feature2'), True)
|
|
|
621 |
self.assertEquals(impl.has_ref('Feature2.set1.sub1'), True)
|
|
|
622 |
self.assertEquals(impl.has_ref('Feature2.set1.sub2'), True)
|
|
|
623 |
self.assertEquals(impl.has_ref('Feature1.UnicodeValueSetting'), True)
|
|
|
624 |
|
|
|
625 |
def test_has_ref_external_template(self):
|
|
3
|
626 |
(config,impl) = self.load_impl('Layer1/implml/has_ref_template_test3.templateml')
|
|
0
|
627 |
self.assertEquals(impl.has_ref('Feature1.StringSetting_not_found'), False)
|
|
|
628 |
self.assertEquals(impl.has_ref('Feature1.StringSetting1'), True)
|
|
|
629 |
self.assertEquals(impl.has_ref('Feature2'), True)
|
|
|
630 |
self.assertEquals(impl.has_ref('Feature2.set1.sub1'), True)
|
|
|
631 |
self.assertEquals(impl.has_ref('Feature2.set1.sub2'), True)
|
|
|
632 |
self.assertEquals(impl.has_ref('Feature1.UnicodeValueSetting'), True)
|
|
|
633 |
|
|
|
634 |
def test_has_ref_with_featree(self):
|
|
3
|
635 |
(config,impl) = self.load_impl('Layer1/implml/has_ref_template_test.templateml')
|
|
0
|
636 |
self.assertEquals(impl.has_ref('Feature1.StringSetting'), True)
|
|
|
637 |
self.assertEquals(impl.has_ref('Feature2.StringSetting'), True)
|
|
|
638 |
|
|
|
639 |
def test_unicode_in_template_and_value(self):
|
|
|
640 |
OUTPUT_DIR = os.path.join(ROOT_PATH, 'output', 'unicode_test')
|
|
|
641 |
self.remove_if_exists(OUTPUT_DIR)
|
|
|
642 |
|
|
|
643 |
fs = filestorage.FileStorage(testdata)
|
|
|
644 |
p = api.Project(fs)
|
|
|
645 |
config = p.get_configuration('root1.confml')
|
|
|
646 |
impls = plugin.get_impl_set(config,'unicode_template_test\.templateml$')
|
|
3
|
647 |
gc = plugin.GenerationContext(output=OUTPUT_DIR,
|
|
|
648 |
configuration=config)
|
|
|
649 |
impls.generate(gc)
|
|
0
|
650 |
self.assert_exists_and_contains_something(os.path.join(OUTPUT_DIR, "unicode_template_test.txt"))
|
|
|
651 |
|
|
|
652 |
# Check that the output exists and contains expected lines
|
|
|
653 |
f = open(os.path.join(OUTPUT_DIR, "unicode_template_test.txt"), "rb")
|
|
|
654 |
try: data = f.read().decode('utf-8')
|
|
|
655 |
finally: f.close()
|
|
|
656 |
self.assertTrue(data.find(u'Value of Feature1.UnicodeValueSetting: カタカナ') != -1)
|
|
|
657 |
self.assertTrue(data.find(u'Unicode from template: ελληνικά') != -1)
|
|
|
658 |
|
|
|
659 |
def test_create_context_dict_and_list(self):
|
|
|
660 |
config = self.load_config('create_dict_test.confml')
|
|
|
661 |
impls = plugin.get_impl_set(config, r'^create_dict_test/implml/test\.templateml$')
|
|
|
662 |
self.assertEquals(1, len(impls))
|
|
|
663 |
impl = iter(impls).next()
|
|
|
664 |
context = impl.create_dict()
|
|
|
665 |
feat_tree = context['feat_tree']
|
|
|
666 |
feat_list = context['feat_list']
|
|
|
667 |
self.assertEqual(context['configuration'], config)
|
|
|
668 |
|
|
|
669 |
# Check the created dictionary
|
|
|
670 |
expected_tree_file = os.path.join(ROOT_PATH, 'create_dict_test', 'expected_tree.txt')
|
|
|
671 |
expected_tree = eval(self.read_data_from_file(expected_tree_file).replace('\r', ''))
|
|
|
672 |
if feat_tree != expected_tree:
|
|
|
673 |
dir = os.path.join(ROOT_PATH, "temp", "create_dict_test", "tree")
|
|
|
674 |
self.create_dir(dir)
|
|
|
675 |
filename = os.path.join(dir, "expected.txt")
|
|
|
676 |
self.write_data_to_file(filename, self.feature_tree_to_str(expected_tree))
|
|
|
677 |
filename = os.path.join(dir, "actual.txt")
|
|
|
678 |
self.write_data_to_file(filename, self.feature_tree_to_str(feat_tree))
|
|
|
679 |
self.fail("Feature tree is not what was expected, see the files in '%s'" % dir)
|
|
|
680 |
|
|
|
681 |
# Check the created list
|
|
|
682 |
expected_list_file = os.path.join(ROOT_PATH, 'create_dict_test', 'expected_list.txt')
|
|
|
683 |
expected_list = eval(self.read_data_from_file(expected_list_file).replace('\r', ''))
|
|
|
684 |
if feat_list != expected_list:
|
|
|
685 |
dir = os.path.join(ROOT_PATH, "temp", "create_dict_test", "list")
|
|
|
686 |
self.create_dir(dir)
|
|
|
687 |
filename = os.path.join(dir, "expected.txt")
|
|
|
688 |
self.write_data_to_file(filename, self.feature_list_to_str(expected_list))
|
|
|
689 |
filename = os.path.join(dir, "actual.txt")
|
|
|
690 |
self.write_data_to_file(filename, self.feature_list_to_str(feat_list))
|
|
3
|
691 |
self.fail("Feature list is not what was expected, see the files in '%s'" % dir)
|
|
0
|
692 |
|
|
|
693 |
def feature_tree_to_str(self, d, indent_amount=0):
|
|
|
694 |
"""
|
|
|
695 |
Pretty-print a feature tree dictionary into a string.
|
|
|
696 |
"""
|
|
|
697 |
INDENT_AMOUNT = 4
|
|
|
698 |
indent = indent_amount * ' '
|
|
|
699 |
temp = ['{']
|
|
|
700 |
if len(d) > 0: temp.append('\n')
|
|
|
701 |
|
|
|
702 |
indent += (INDENT_AMOUNT + indent_amount) * ' '
|
|
|
703 |
|
|
|
704 |
# Function for sorting the dict contents so that keys starting with
|
|
|
705 |
# '_' are first
|
|
|
706 |
def key_func(key_and_value):
|
|
|
707 |
key = key_and_value[0]
|
|
|
708 |
if key.startswith('_'): return '\x00' + key
|
|
|
709 |
else: return key
|
|
|
710 |
|
|
|
711 |
for key, value in sorted(d.items(), key=key_func):
|
|
|
712 |
temp.append(indent)
|
|
3
|
713 |
if isinstance(value, (dict, templatemlplugin.FeatureDictProxy)):
|
|
0
|
714 |
temp.append("%r: %s," % (key, self.feature_tree_to_str(value, indent_amount + INDENT_AMOUNT)))
|
|
|
715 |
else:
|
|
|
716 |
temp.append("%r: %r," % (key, value))
|
|
|
717 |
temp.append('\n')
|
|
|
718 |
|
|
|
719 |
if len(d) > 0: temp.append(indent)
|
|
|
720 |
temp.append('}')
|
|
|
721 |
return ''.join(temp)
|
|
|
722 |
|
|
|
723 |
def feature_list_to_str(self, lst):
|
|
|
724 |
"""
|
|
|
725 |
Pretty-print a feature list into a string.
|
|
|
726 |
"""
|
|
|
727 |
temp = ['[\n']
|
|
|
728 |
for item in lst:
|
|
3
|
729 |
if isinstance(item, (dict, templatemlplugin.FeatureDictProxy)): temp.append(self.feature_tree_to_str(item))
|
|
0
|
730 |
else: temp.append(repr(item))
|
|
|
731 |
temp.append(',\n')
|
|
|
732 |
temp.append(']')
|
|
|
733 |
return ''.join(temp)
|
|
|
734 |
|
|
|
735 |
|
|
|
736 |
def test_utf_bom_support(self):
|
|
|
737 |
OUTPUT_DIR = os.path.join(ROOT_PATH, 'temp/utf_bom_test')
|
|
|
738 |
self.recreate_dir(OUTPUT_DIR)
|
|
3
|
739 |
(config,impl) = self.load_impl('Layer1/implml/utf_bom_test.templateml')
|
|
|
740 |
gc = plugin.GenerationContext(output=OUTPUT_DIR,
|
|
|
741 |
configuration=config)
|
|
|
742 |
impl.generate(gc)
|
|
0
|
743 |
|
|
|
744 |
def check(file, contents):
|
|
|
745 |
FILE = os.path.join(OUTPUT_DIR, file)
|
|
|
746 |
self.assert_file_content_equals(FILE, contents)
|
|
|
747 |
|
|
|
748 |
h = hex_to_bindata
|
|
|
749 |
|
|
|
750 |
# The all-around default should be UTF-8 without BOM
|
|
|
751 |
check('default.txt', h('31 30 30 E282AC'))
|
|
|
752 |
|
|
|
753 |
check('iso_8859_15_default.txt', h('31 30 30 A4'))
|
|
|
754 |
check('utf8_default.txt', h('31 30 30 E282AC'))
|
|
|
755 |
check('utf16be_default.txt', h('0031 0030 0030 20AC'))
|
|
|
756 |
check('utf16le_default.txt', h('3100 3000 3000 AC20'))
|
|
|
757 |
|
|
|
758 |
check('iso_8859_15_no_bom.txt', h('31 30 30 A4'))
|
|
|
759 |
check('utf8_no_bom.txt', h('31 30 30 E282AC'))
|
|
|
760 |
check('utf16be_no_bom.txt', h('0031 0030 0030 20AC'))
|
|
|
761 |
check('utf16le_no_bom.txt', h('3100 3000 3000 AC20'))
|
|
|
762 |
|
|
|
763 |
check('iso_8859_15_with_bom.txt', h('31 30 30 A4'))
|
|
|
764 |
check('utf8_with_bom.txt', h('EFBBBF 31 30 30 E282AC'))
|
|
|
765 |
check('utf16be_with_bom.txt', h('FEFF 0031 0030 0030 20AC'))
|
|
|
766 |
check('utf16le_with_bom.txt', h('FFFE 3100 3000 3000 AC20'))
|
|
|
767 |
|
|
|
768 |
if sys.byteorder == 'little':
|
|
|
769 |
check('utf16_default.txt', h('FFFE 3100 3000 3000 AC20'))
|
|
|
770 |
check('utf16_no_bom.txt', h('3100 3000 3000 AC20'))
|
|
|
771 |
check('utf16_with_bom.txt', h('FFFE 3100 3000 3000 AC20'))
|
|
|
772 |
else:
|
|
|
773 |
check('utf16_default.txt', h('FEFF 0031 0030 0030 20AC'))
|
|
|
774 |
check('utf16_no_bom.txt', h('0031 0030 0030 20AC'))
|
|
|
775 |
check('utf16_with_bom.txt', h('FEFF 0031 0030 0030 20AC'))
|
|
|
776 |
|
|
|
777 |
def test_invalid_encoding(self):
|
|
|
778 |
DATA = """<?xml version="1.0" encoding="UTF-8"?>
|
|
|
779 |
<templateml xmlns=\"http://www.s60.com/xml/templateml/1\">
|
|
|
780 |
<output file="test.txt" encoding="foocode">foo</output>
|
|
|
781 |
</templateml>"""
|
|
|
782 |
reader = templatemlplugin.TemplatemlImplReader()
|
|
3
|
783 |
reader.fromstring(DATA)
|
|
|
784 |
self.assertRaises(exceptions.ParseError, reader.expand_output_refs_by_default_view)
|
|
|
785 |
|
|
|
786 |
def test_generate_from_template_with_feat_tree_iteration(self):
|
|
|
787 |
OUTPUT_DIR = os.path.join(ROOT_PATH, 'temp/feat_tree_iteration')
|
|
|
788 |
self.recreate_dir(OUTPUT_DIR)
|
|
|
789 |
(config,impl) = self.load_impl('Layer1/implml/feat_tree_iteration_test.templateml')
|
|
|
790 |
gc = plugin.GenerationContext(output=OUTPUT_DIR,
|
|
|
791 |
configuration=config)
|
|
|
792 |
impl.generate(gc)
|
|
|
793 |
|
|
|
794 |
OUTPUT_FILE = os.path.join(OUTPUT_DIR, 'feat_tree_iteration_test.txt')
|
|
|
795 |
self.assert_exists_and_contains_something(OUTPUT_FILE)
|
|
|
796 |
self.assert_file_content_equals(OUTPUT_FILE,
|
|
|
797 |
u"\n"\
|
|
|
798 |
u"Boolean setting = True\n"\
|
|
|
799 |
u"File setting = default_file.txt\n"\
|
|
|
800 |
u"Folder setting = default_folder\n"\
|
|
|
801 |
u"Int setting = 10\n"\
|
|
|
802 |
u"Real setting = 3.14\n"\
|
|
|
803 |
u"Selection setting = 1\n"\
|
|
|
804 |
u"Sequence setting = [[[None, None], 1.25, [None, None], 128, 'def1', False, '1'], [[None, None], 1.5, [None, None], 256, 'def2', False, '1']]\n"\
|
|
|
805 |
u"String setting = John Doe\n"\
|
|
|
806 |
u"String for unicode value test = カタカナ\n".encode('utf-8'))
|
|
0
|
807 |
|
|
3
|
808 |
def test_generate_from_template_generation_context_accessed(self):
|
|
|
809 |
OUTPUT_DIR = os.path.join(ROOT_PATH, 'temp/access_context')
|
|
|
810 |
self.recreate_dir(OUTPUT_DIR)
|
|
|
811 |
(config,impl) = self.load_impl('Layer1/implml/access_context.templateml')
|
|
|
812 |
context = plugin.GenerationContext(output=OUTPUT_DIR,
|
|
|
813 |
configuration=config)
|
|
|
814 |
context.tags = {'sometag': ['foo', 'bar']}
|
|
|
815 |
impl.generate(context)
|
|
|
816 |
|
|
|
817 |
OUTPUT_FILE = os.path.join(OUTPUT_DIR, 'access_context.txt')
|
|
|
818 |
self.assert_exists_and_contains_something(OUTPUT_FILE)
|
|
|
819 |
self.assert_file_content_equals(OUTPUT_FILE,
|
|
|
820 |
"Tags: {'sometag': ['foo', 'bar']}")
|
|
|
821 |
|
|
|
822 |
def test_invalid_ref_in_template(self):
|
|
|
823 |
OUTPUT_DIR = os.path.join(ROOT_PATH, 'temp/invalid_ref')
|
|
|
824 |
self.recreate_dir(OUTPUT_DIR)
|
|
|
825 |
(config,impl) = self.load_impl('Layer1/implml/invalid_ref.templateml')
|
|
|
826 |
context = plugin.GenerationContext(output=OUTPUT_DIR,
|
|
|
827 |
configuration=config)
|
|
|
828 |
|
|
|
829 |
log_file, handler, logger = self._prepare_log('invalid_refs.log')
|
|
|
830 |
impl.generate(context)
|
|
|
831 |
logger.removeHandler(handler)
|
|
|
832 |
|
|
|
833 |
self.assert_file_content_equals(os.path.join(OUTPUT_DIR, 'invalid_ref_1.txt'), "")
|
|
|
834 |
self.assert_file_content_equals(os.path.join(OUTPUT_DIR, 'invalid_ref_2.txt'), "")
|
|
|
835 |
self.assert_file_content_equals(os.path.join(OUTPUT_DIR, 'invalid_ref_3.txt'), "")
|
|
|
836 |
|
|
|
837 |
self.assert_file_contains(log_file,
|
|
|
838 |
["TemplatemlImpl(ref='Layer1/implml/invalid_ref.templateml', type='templateml', lineno=2): Failed to generate output: NotFound: Feature 'Foo' not found",
|
|
|
839 |
"TemplatemlImpl(ref='Layer1/implml/invalid_ref.templateml', type='templateml', lineno=2): Failed to generate output: NotFound: Feature 'Feature1.Nonexistent' not found",
|
|
|
840 |
"TemplatemlImpl(ref='Layer1/implml/invalid_ref.templateml', type='templateml', lineno=2): Failed to generate output: NotFound: Feature 'Feature1.SequenceSetting.Nonexistent' not found"])
|
|
|
841 |
|
|
|
842 |
def _prepare_log(self, log_file, level=logging.DEBUG, formatter="%(levelname)s - %(name)s - %(message)s", logger='cone'):
|
|
|
843 |
FULL_PATH = os.path.join(ROOT_PATH, "temp/logs", log_file)
|
|
|
844 |
self.remove_if_exists(FULL_PATH)
|
|
|
845 |
self.create_dir_for_file_path(FULL_PATH)
|
|
|
846 |
|
|
|
847 |
handler = logging.FileHandler(FULL_PATH)
|
|
|
848 |
handler.setLevel(level)
|
|
|
849 |
frm = logging.Formatter(formatter)
|
|
|
850 |
handler.setFormatter(frm)
|
|
|
851 |
logger = logging.getLogger(logger)
|
|
|
852 |
logger.addHandler(handler)
|
|
|
853 |
|
|
|
854 |
return [FULL_PATH, handler, logger]
|
|
0
|
855 |
|
|
|
856 |
class TestExtractRefsFromTemplate(unittest.TestCase):
|
|
|
857 |
def test_extract_refs_from_template(self):
|
|
|
858 |
def t(data, expected_refs):
|
|
|
859 |
actual_refs = templatemlplugin.TemplatemlImpl._extract_refs_from_template(data)
|
|
|
860 |
self.assertEquals(expected_refs, actual_refs)
|
|
|
861 |
|
|
|
862 |
t("some text {{ feat_tree.Foo }} more text",
|
|
|
863 |
['Foo'])
|
|
|
864 |
t("some text {{ feat_tree.Foo.Bar }} more text",
|
|
|
865 |
['Foo.Bar'])
|
|
|
866 |
t("some text {{feat_tree.Foo.Bar}} more text",
|
|
|
867 |
['Foo.Bar'])
|
|
|
868 |
t("some text {{ feat_tree.Foo.Bar.Baz }} more text",
|
|
|
869 |
['Foo.Bar.Baz'])
|
|
|
870 |
t("some text {{ feat_tree.Foo.Bar.Baz._value }} more text",
|
|
|
871 |
['Foo.Bar.Baz'])
|
|
|
872 |
t(u"some text {{ feat_tree.ударения.ελληνικά }} more text",
|
|
|
873 |
[u'ударения.ελληνικά'])
|
|
|
874 |
t(u"some text {{ feat_tree.ударения.ελληνικά._value }} more text",
|
|
|
875 |
[u'ударения.ελληνικά'])
|
|
|
876 |
t("some text {{ feat_tree.MyFeature.MySetting|some_filter }} more text",
|
|
|
877 |
['MyFeature.MySetting'])
|
|
|
878 |
t(u"some text {{ feat_tree.MyFeature.MySetting|some_filter }} more text",
|
|
|
879 |
['MyFeature.MySetting'])
|
|
|
880 |
t("some text {{ feat_tree.MyFeature.MySetting | some_filter }} more text",
|
|
|
881 |
['MyFeature.MySetting'])
|
|
|
882 |
t("some text {{ feat_tree.MyFeature.MySetting._value|some_filter }} more text",
|
|
|
883 |
['MyFeature.MySetting'])
|
|
|
884 |
t("some text {{ feat_tree.Xyz.Zyx._type }} more {{feat_tree.Xyz.Zyx._type}} text",
|
|
|
885 |
['Xyz.Zyx', 'Xyz.Zyx'])
|
|
|
886 |
t("some text {% for x in feat_tree.MyFeature.MySetting._value|sort %} more text",
|
|
|
887 |
['MyFeature.MySetting'])
|
|
|
888 |
|
|
|
889 |
if __name__ == '__main__':
|
|
|
890 |
unittest.main()
|