|
1 # |
|
2 # Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 # All rights reserved. |
|
4 # This component and the accompanying materials are made available |
|
5 # under the terms of the License "Eclipse Public License v1.0" |
|
6 # which accompanies this distribution, and is available |
|
7 # at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 # |
|
9 # Initial Contributors: |
|
10 # Nokia Corporation - initial contribution. |
|
11 # |
|
12 # Contributors: |
|
13 # |
|
14 # Description: |
|
15 # raptor_meta_unit module |
|
16 # This module tests the classes forming the Raptor bld.inf and .mmp parsing support |
|
17 # |
|
18 |
|
19 import raptor |
|
20 import raptor_meta |
|
21 import raptor_utilities |
|
22 import raptor_data |
|
23 import mmpparser |
|
24 import unittest |
|
25 import generic_path |
|
26 import os |
|
27 import sys |
|
28 import re |
|
29 |
|
30 class TestRaptorMeta(unittest.TestCase): |
|
31 |
|
32 def setUp(self): |
|
33 self.raptor = raptor.Raptor() |
|
34 self.__testRoot = generic_path.Path(os.environ[raptor.env], "test").Absolute() |
|
35 self.__makefilePathTestRoot = self.__testRoot |
|
36 self.__epocroot = self.__testRoot |
|
37 self.__variant_cfg_root = self.__testRoot.Append('metadata/config') |
|
38 self.__variant_cfg = self.__variant_cfg_root.Append('test_cfg.cfg') |
|
39 self.__platmacros_armv5 = "ARMCC EPOC32 MARM EABI ARMCC_2 ARMCC_2_2 GENERIC_MARM MARM_ARMV5" |
|
40 self.__platmacros_armv6 = "ARMCC EPOC32 MARM EABI ARMCC_2 ARMCC_2_2 GENERIC_MARM MARM_ARMV5 ARMV6" |
|
41 self.__platmacros_armv7 = "ARMCC EPOC32 MARM EABI ARMCC_2 ARMCC_2_2 GENERIC_MARM MARM_ARMV5 ARMV7" |
|
42 self.__platmacros_winscw = "CW32 WINS WINSCW" |
|
43 |
|
44 self.variant_hrh = self.__testRoot.Append('metadata/include/test_hrh.hrh') |
|
45 |
|
46 self.__OSRoot = "" |
|
47 if raptor_utilities.getOSFileSystem() == "cygwin": |
|
48 self.__OSRoot = str(self.__makefilePathTestRoot)[:2] |
|
49 |
|
50 # we need some sort of generic platform for preprocessing |
|
51 self.defaultPlatform = { 'PLATFORM': 'generic', |
|
52 'EPOCROOT': self.__epocroot, |
|
53 'VARIANT_HRH': self.variant_hrh, |
|
54 'SYSTEMINCLUDE' : '', |
|
55 'id': 0, |
|
56 'key': '0000000000000000', |
|
57 'key_md5': '0000000000000000', |
|
58 'ISFEATUREVARIANT' : False, |
|
59 'PLATMACROS' : self.__platmacros_armv5, |
|
60 'SBS_BUILD_DIR' : str(self.__epocroot) + "/epoc32/build", |
|
61 'METADEPS' : [] |
|
62 } |
|
63 # For testing purposes, the ARMV5 platform is flagged here as feature variant. |
|
64 # In metadata processing terms, this means that the location of the HRH file |
|
65 # is not automatically added to the SYSTEMINCLUDE path, and so is specified |
|
66 # directly. |
|
67 self.ARMV5 = { 'PLATFORM': 'ARMV5', |
|
68 'EPOCROOT': self.__epocroot, |
|
69 'VARIANT_HRH': self.variant_hrh, |
|
70 'SYSTEMINCLUDE' : str(self.variant_hrh.Dir()), |
|
71 'id': 1, |
|
72 'key': '1111111111111111', |
|
73 'key_md5': '1111111111111111', |
|
74 'ISFEATUREVARIANT' : True, |
|
75 'PLATMACROS' : self.__platmacros_armv5, |
|
76 'SBS_BUILD_DIR' : str(self.__epocroot) + "/epoc32/build", |
|
77 'METADEPS' : [] |
|
78 } |
|
79 self.ARMV5SMP = { 'PLATFORM': 'ARMV5SMP', |
|
80 'EPOCROOT': self.__epocroot, |
|
81 'VARIANT_HRH': self.variant_hrh, |
|
82 'SYSTEMINCLUDE' : str(self.variant_hrh.Dir()), |
|
83 'id': 1, |
|
84 'key': '1111111111111111', |
|
85 'key_md5': '1111111111111111', |
|
86 'ISFEATUREVARIANT' : False, |
|
87 'PLATMACROS' : self.__platmacros_armv5, |
|
88 'SBS_BUILD_DIR' : str(self.__epocroot) + "/epoc32/build", |
|
89 'METADEPS' : [] |
|
90 } |
|
91 self.ARMV6 = { 'PLATFORM': 'ARMV6', |
|
92 'EPOCROOT': self.__epocroot, |
|
93 'VARIANT_HRH': self.variant_hrh, |
|
94 'SYSTEMINCLUDE' : str(self.variant_hrh.Dir()), |
|
95 'id': 1, |
|
96 'key': '1111111111111111', |
|
97 'key_md5': '1111111111111111', |
|
98 'ISFEATUREVARIANT' : False, |
|
99 'PLATMACROS' : self.__platmacros_armv6, |
|
100 'SBS_BUILD_DIR' : str(self.__epocroot) + "/epoc32/build", |
|
101 'METADEPS' : [] |
|
102 } |
|
103 self.ARMV7 = { 'PLATFORM': 'ARMV7', |
|
104 'EPOCROOT': self.__epocroot, |
|
105 'VARIANT_HRH': self.variant_hrh, |
|
106 'SYSTEMINCLUDE' : str(self.variant_hrh.Dir()), |
|
107 'id': 1, |
|
108 'key': '1111111111111111', |
|
109 'key_md5': '1111111111111111', |
|
110 'ISFEATUREVARIANT' : False, |
|
111 'PLATMACROS' : self.__platmacros_armv7, |
|
112 'SBS_BUILD_DIR' : str(self.__epocroot) + "/epoc32/build", |
|
113 'METADEPS' : [] |
|
114 } |
|
115 self.ARMV7SMP = { 'PLATFORM': 'ARMV7SMP', |
|
116 'EPOCROOT': self.__epocroot, |
|
117 'VARIANT_HRH': self.variant_hrh, |
|
118 'SYSTEMINCLUDE' : str(self.variant_hrh.Dir()), |
|
119 'id': 1, |
|
120 'key': '1111111111111111', |
|
121 'key_md5': '1111111111111111', |
|
122 'ISFEATUREVARIANT' : False, |
|
123 'PLATMACROS' : self.__platmacros_armv7, |
|
124 'SBS_BUILD_DIR' : str(self.__epocroot) + "/epoc32/build", |
|
125 'METADEPS' : [] |
|
126 } |
|
127 self.WINSCW = { 'PLATFORM': 'WINSCW', |
|
128 'EPOCROOT': self.__epocroot, |
|
129 'VARIANT_HRH': self.variant_hrh, |
|
130 'SYSTEMINCLUDE' : '', |
|
131 'id': 2, |
|
132 'key': '2222222222222222', |
|
133 'key_md5': '2222222222222222', |
|
134 'ISFEATUREVARIANT' : False, |
|
135 'PLATMACROS' : self.__platmacros_winscw, |
|
136 'SBS_BUILD_DIR' : str(self.__epocroot) + "/epoc32/build", |
|
137 'METADEPS' : [] |
|
138 } |
|
139 |
|
140 self.testPlats = [self.ARMV5, self.ARMV5SMP, self.ARMV6, self.ARMV7, self.ARMV7SMP, self.WINSCW] |
|
141 |
|
142 # Get the version of CPP that we are using and hope it's correct |
|
143 # since there is no tool check. |
|
144 if os.environ.has_key('SBS_GNUCPP'): |
|
145 self.__gnucpp = os.environ['SBS_GNUCPP'] |
|
146 else: |
|
147 self.__gnucpp = "cpp" |
|
148 |
|
149 def testPreProcessor(self): |
|
150 # Just test for correct behaviour on failure, other tests excercise correct behaviour on success |
|
151 preProcessor = raptor_meta.PreProcessor('cpp_that_does_not_exist', |
|
152 '-undef -nostdinc', |
|
153 '-I', '-D', '-include', |
|
154 self.raptor) |
|
155 |
|
156 try: |
|
157 preProcessor.preprocess() |
|
158 except Exception, e: |
|
159 self.assertTrue(isinstance(e, raptor_meta.MetaDataError)) |
|
160 self.assertTrue(re.match('^Preprocessor exception', e.Text)) |
|
161 |
|
162 def testConfigParsing(self): |
|
163 # .cfg file specified, but does not exist |
|
164 try: |
|
165 configDetails = raptor_meta.getVariantCfgDetail(self.__epocroot, |
|
166 self.__variant_cfg_root.Append("missing")) |
|
167 except Exception, e: |
|
168 self.assertTrue(isinstance(e, raptor_meta.MetaDataError)) |
|
169 self.assertTrue(re.match('^Could not read variant configuration file.*$', e.Text)) |
|
170 |
|
171 # No .hrh file specified |
|
172 try: |
|
173 configDetails = raptor_meta.getVariantCfgDetail(self.__epocroot, |
|
174 self.__variant_cfg_root.Append("empty_cfg.cfg")) |
|
175 except Exception, e: |
|
176 self.assertTrue(isinstance(e, raptor_meta.MetaDataError)) |
|
177 self.assertTrue(re.match('No variant file specified in .*', e.Text)) |
|
178 |
|
179 # .hrh file does not exist |
|
180 try: |
|
181 configDetails = raptor_meta.getVariantCfgDetail(self.__epocroot, |
|
182 self.__variant_cfg_root.Append("invalid_cfg.cfg")) |
|
183 except Exception, e: |
|
184 self.assertTrue(isinstance(e, raptor_meta.MetaDataError)) |
|
185 self.assertTrue(re.match('Variant file .* does not exist', e.Text)) |
|
186 |
|
187 # Valid .cfg file |
|
188 configDetails = raptor_meta.getVariantCfgDetail(self.__epocroot, |
|
189 self.__variant_cfg) |
|
190 self.failUnless(configDetails) |
|
191 |
|
192 found_variant_hrh = str(configDetails.get('VARIANT_HRH')) |
|
193 expected_variant_hrh = str(self.variant_hrh) |
|
194 |
|
195 self.assertEqual(found_variant_hrh, expected_variant_hrh) |
|
196 |
|
197 |
|
198 def __testBuildPlatforms(self, aRootBldInfLocation, aBldInfFile, |
|
199 aExpectedBldInfPlatforms, aExpectedBuildablePlatforms): |
|
200 bldInfFile = aRootBldInfLocation.Append(aBldInfFile) |
|
201 self.failUnless(bldInfFile) |
|
202 |
|
203 depfiles=[] |
|
204 bldInfObject = raptor_meta.BldInfFile(bldInfFile, self.__gnucpp, depfiles=depfiles, log=self.raptor) |
|
205 |
|
206 bp = bldInfObject.getBuildPlatforms(self.defaultPlatform) |
|
207 self.assertEquals(bp, aExpectedBldInfPlatforms) |
|
208 |
|
209 buildableBldInfBuildPlatforms = raptor_meta.getBuildableBldInfBuildPlatforms(bp, |
|
210 'ARMV5 ARMV7 WINSCW', |
|
211 'ARMV5 ARMV5SMP ARMV7 WINSCW', |
|
212 'ARMV5 ARMV7 WINSCW') |
|
213 |
|
214 for expectedBuildablePlatform in aExpectedBuildablePlatforms: |
|
215 self.assertTrue(expectedBuildablePlatform in buildableBldInfBuildPlatforms) |
|
216 |
|
217 self.assertEqual(len(aExpectedBuildablePlatforms), |
|
218 len(buildableBldInfBuildPlatforms)) |
|
219 return |
|
220 |
|
221 def testBldInfPlatformDeduction(self): |
|
222 bldInfTestRoot = self.__testRoot.Append('metadata/project/bld.infs') |
|
223 |
|
224 self.__testBuildPlatforms(bldInfTestRoot, 'no_prj_platforms.inf', |
|
225 [], ['ARMV7', 'ARMV5', 'WINSCW', 'GCCXML']) |
|
226 self.__testBuildPlatforms(bldInfTestRoot, 'no_plats.inf', |
|
227 [], ['ARMV7', 'ARMV5', 'WINSCW', 'GCCXML']) |
|
228 self.__testBuildPlatforms(bldInfTestRoot, 'default_plats.inf', |
|
229 ['DEFAULT'], ['ARMV7', 'ARMV5', 'WINSCW', 'GCCXML']) |
|
230 self.__testBuildPlatforms(bldInfTestRoot, 'default_plats_minus_plat.inf', |
|
231 ['DEFAULT', '-WINSCW'], ['ARMV7', 'ARMV5', 'GCCXML']) |
|
232 self.__testBuildPlatforms(bldInfTestRoot, 'single_plat.inf', |
|
233 ['ARMV5'], ['ARMV5', 'GCCXML']) |
|
234 self.__testBuildPlatforms(bldInfTestRoot, 'multiple_plats.inf', |
|
235 ['ARMV5', 'WINSCW', 'TOOLS'], ['ARMV5', 'WINSCW', 'TOOLS', 'GCCXML']) |
|
236 return |
|
237 |
|
238 def __testBldInfTestCode(self, aTestRoot, aBldInf, aActual, aExpected): |
|
239 loop_number = 0 |
|
240 for actual in aActual: |
|
241 self.assertEquals(actual, aExpected[loop_number]) |
|
242 loop_number += 1 |
|
243 |
|
244 def testBldInfTestType(self): |
|
245 bldInfTestRoot = self.__testRoot.Append('metadata/project/mmps/test_mmps') |
|
246 |
|
247 bldInfFile = bldInfTestRoot.Append('test_mmps.inf') |
|
248 depfiles = [] |
|
249 bldInfObject = raptor_meta.BldInfFile(bldInfFile, self.__gnucpp, depfiles=depfiles, log=self.raptor) |
|
250 testArmv5Platform = self.ARMV5 |
|
251 testArmv5Platform["TESTCODE"] = True |
|
252 bldInfObject.getRomTestType(testArmv5Platform) |
|
253 |
|
254 self.__testBldInfTestCode(bldInfTestRoot, 'test_mmps.inf', |
|
255 [bldInfObject.testManual, bldInfObject.testAuto], [1, 1]) |
|
256 |
|
257 def __testExport(self, aExportObject, aSource, aDestination, aAction): |
|
258 self.assertEquals(aExportObject.getSource(), aSource) |
|
259 self.assertEqualsOrContainsPath(aExportObject.getDestination(), aDestination) |
|
260 self.assertEquals(aExportObject.getAction(), aAction) |
|
261 |
|
262 def assertEqualsOrContainsPath(self, aRequirement, aCandidate): |
|
263 # If aRequirement is a list, which it might well be, we should |
|
264 # assert that aPathString is contained in it |
|
265 # If aRequirement not a list, it will be a string, and |
|
266 # we should assert equality of the strings |
|
267 # On windows we shouldn't care about the case of the drive letter. |
|
268 |
|
269 if isinstance(aRequirement, list): |
|
270 pathsequal = False |
|
271 for r in aRequirement: |
|
272 pathsequal = path_compare_notdrivelettercase(r,aCandidate) or pathsequal |
|
273 self.assertTrue(pathsequal) |
|
274 else: |
|
275 self.assertTrue(path_compare_notdrivelettercase(aRequirement,aCandidate)) |
|
276 |
|
277 def testBldInfExports(self): |
|
278 bldInfTestRoot = self.__testRoot.Append('metadata/project/bld.infs') |
|
279 bldInfMakefilePathTestRoot = str(self.__makefilePathTestRoot) + '/metadata/project/' |
|
280 |
|
281 depfiles = [] |
|
282 bldInfObject = raptor_meta.BldInfFile(bldInfTestRoot.Append('exports.inf'), |
|
283 self.__gnucpp, depfiles=depfiles, log=self.raptor) |
|
284 |
|
285 exports = bldInfObject.getExports(self.defaultPlatform) |
|
286 |
|
287 # export1.h |
|
288 self.__testExport(exports[0], |
|
289 bldInfMakefilePathTestRoot+'bld.infs/export1.h', |
|
290 '$(EPOCROOT)/epoc32/include/export1.h', |
|
291 'copy') |
|
292 |
|
293 # export2.h export_test\export2.h |
|
294 self.__testExport(exports[1], |
|
295 bldInfMakefilePathTestRoot+'bld.infs/export2.h', |
|
296 '$(EPOCROOT)/epoc32/include/export_test/export2.h', |
|
297 'copy') |
|
298 |
|
299 # export3.h ..\export_test\export3.h |
|
300 self.__testExport(exports[2], |
|
301 bldInfMakefilePathTestRoot+'bld.infs/export3.h', |
|
302 '$(EPOCROOT)/epoc32/export_test/export3.h', |
|
303 'copy') |
|
304 |
|
305 # export4.h \export_test_abs\export4.h |
|
306 self.__testExport(exports[3], |
|
307 bldInfMakefilePathTestRoot+'bld.infs/export4.h', |
|
308 self.__OSRoot+'/export_test_abs/export4.h', |
|
309 'copy') |
|
310 |
|
311 # export5.h \epoc32\export_test_abs\export5.h |
|
312 self.__testExport(exports[4], |
|
313 bldInfMakefilePathTestRoot+'bld.infs/export5.h', |
|
314 '$(EPOCROOT)/epoc32/export_test_abs/export5.h', |
|
315 'copy') |
|
316 |
|
317 # export6.h |..\export_test_rel\export6.h |
|
318 self.__testExport(exports[5], |
|
319 bldInfMakefilePathTestRoot+'bld.infs/export6.h', |
|
320 bldInfMakefilePathTestRoot+'export_test_rel/export6.h', |
|
321 'copy') |
|
322 |
|
323 # export6.h |\export_test_rel\export7.h |
|
324 self.__testExport(exports[6], |
|
325 bldInfMakefilePathTestRoot+'bld.infs/export7.h', |
|
326 bldInfMakefilePathTestRoot+'bld.infs/export_test_rel/export7.h', |
|
327 'copy') |
|
328 |
|
329 # export7.h |export_test_rel\export8.h |
|
330 self.__testExport(exports[7], |
|
331 bldInfMakefilePathTestRoot+'bld.infs/export8.h', |
|
332 bldInfMakefilePathTestRoot+'bld.infs/export_test_rel/export8.h', |
|
333 'copy') |
|
334 |
|
335 # :zip export9.zip |
|
336 self.__testExport(exports[8], |
|
337 bldInfMakefilePathTestRoot+'bld.infs/export9.zip', |
|
338 '$(EPOCROOT)', |
|
339 'unzip') |
|
340 |
|
341 # :zip export10.zip export_test |
|
342 self.__testExport(exports[9], |
|
343 bldInfMakefilePathTestRoot+'bld.infs/export10.zip', |
|
344 '$(EPOCROOT)/export_test', |
|
345 'unzip') |
|
346 |
|
347 # :zip export11.zip /export_test |
|
348 self.__testExport(exports[10], |
|
349 bldInfMakefilePathTestRoot+'bld.infs/export11.zip', |
|
350 self.__OSRoot+'/export_test', |
|
351 'unzip') |
|
352 |
|
353 # :zip export12.zip /epoc32/export_test |
|
354 self.__testExport(exports[11], |
|
355 bldInfMakefilePathTestRoot+'bld.infs/export12.zip', |
|
356 '$(EPOCROOT)/epoc32/export_test', |
|
357 'unzip') |
|
358 |
|
359 # export13.rsc z:/resource/app/export13.rsc |
|
360 # Once for each of the three locations for emulated drives |
|
361 # epoc32/data/z/resource/app/export13.rsc *and* in |
|
362 # epoc32/release/winscw/udeb/z/resource/app/export13.rsc *and* in |
|
363 # epoc32/release/winscw/urel/z/resource/app/export13.rsc |
|
364 self.__testExport(exports[12], |
|
365 bldInfMakefilePathTestRoot+'bld.infs/export13.rsc', |
|
366 '$(EPOCROOT)/epoc32/data/z/resource/app/export13.rsc', |
|
367 'copy') |
|
368 |
|
369 self.__testExport(exports[12], |
|
370 bldInfMakefilePathTestRoot+'bld.infs/export13.rsc', |
|
371 '$(EPOCROOT)/epoc32/release/winscw/udeb/z/resource/app/export13.rsc', |
|
372 'copy') |
|
373 |
|
374 self.__testExport(exports[12], |
|
375 bldInfMakefilePathTestRoot+'bld.infs/export13.rsc', |
|
376 '$(EPOCROOT)/epoc32/release/winscw/urel/z/resource/app/export13.rsc', |
|
377 'copy') |
|
378 |
|
379 |
|
380 testExports = bldInfObject.getTestExports(self.defaultPlatform) |
|
381 |
|
382 # testexport1.h |
|
383 self.__testExport(testExports[0], |
|
384 bldInfMakefilePathTestRoot+'bld.infs/testexport1.h', |
|
385 bldInfMakefilePathTestRoot+'bld.infs/testexport1.h', |
|
386 'copy') |
|
387 |
|
388 # testexport2.h export_test_rel\testexport2.h |
|
389 self.__testExport(testExports[1], |
|
390 bldInfMakefilePathTestRoot+'bld.infs/testexport2.h', |
|
391 bldInfMakefilePathTestRoot+'bld.infs/export_test_rel/testexport2.h', |
|
392 'copy') |
|
393 |
|
394 # testexport3.h ..\export_test_rel\testexport3.h |
|
395 self.__testExport(testExports[2], |
|
396 bldInfMakefilePathTestRoot+'bld.infs/testexport3.h', |
|
397 bldInfMakefilePathTestRoot+'export_test_rel/testexport3.h', |
|
398 'copy') |
|
399 |
|
400 # testexport4.h \export_test_abs\testexport4.h |
|
401 self.__testExport(testExports[3], |
|
402 bldInfMakefilePathTestRoot+'bld.infs/testexport4.h', |
|
403 self.__OSRoot+'/export_test_abs/testexport4.h', |
|
404 'copy') |
|
405 |
|
406 # testexport5.h \epoc32\export_test_abs\testexport5.h |
|
407 self.__testExport(testExports[4], |
|
408 bldInfMakefilePathTestRoot+'bld.infs/testexport5.h', |
|
409 '$(EPOCROOT)/epoc32/export_test_abs/testexport5.h', |
|
410 'copy') |
|
411 |
|
412 # testexport6.h |..\export_test_rel\testexport6.h |
|
413 self.__testExport(testExports[5], |
|
414 bldInfMakefilePathTestRoot+'bld.infs/testexport6.h', |
|
415 bldInfMakefilePathTestRoot+'export_test_rel/testexport6.h', |
|
416 'copy') |
|
417 |
|
418 # testexport7.h |\export_test_rel\testexport7.h |
|
419 self.__testExport(testExports[6], |
|
420 bldInfMakefilePathTestRoot+'bld.infs/testexport7.h', |
|
421 bldInfMakefilePathTestRoot+'bld.infs/export_test_rel/testexport7.h', |
|
422 'copy') |
|
423 |
|
424 # testexport8.h |export_test_rel\testexport8.h |
|
425 self.__testExport(testExports[7], |
|
426 bldInfMakefilePathTestRoot+'bld.infs/testexport8.h', |
|
427 bldInfMakefilePathTestRoot+'bld.infs/export_test_rel/testexport8.h', |
|
428 'copy') |
|
429 |
|
430 # :zip testexport9.zip |
|
431 self.__testExport(testExports[8], |
|
432 bldInfMakefilePathTestRoot+'bld.infs/testexport9.zip', |
|
433 '$(EPOCROOT)', |
|
434 'unzip') |
|
435 |
|
436 # :zip testexport10.zip export_test |
|
437 self.__testExport(testExports[9], |
|
438 bldInfMakefilePathTestRoot+'bld.infs/testexport10.zip', |
|
439 '$(EPOCROOT)/export_test', |
|
440 'unzip') |
|
441 |
|
442 # :zip testexport11.zip /export_test |
|
443 self.__testExport(testExports[10], |
|
444 bldInfMakefilePathTestRoot+'bld.infs/testexport11.zip', |
|
445 self.__OSRoot+'/export_test', |
|
446 'unzip') |
|
447 |
|
448 # :zip testexport12.zip /epoc32/export_test |
|
449 self.__testExport(testExports[11], |
|
450 bldInfMakefilePathTestRoot+'bld.infs/testexport12.zip', |
|
451 '$(EPOCROOT)/epoc32/export_test', |
|
452 'unzip') |
|
453 |
|
454 # testexport13.rsc z:/resource/app/testexport13.rsc |
|
455 # Once for each of the three locations for emulated drives |
|
456 # epoc32/data/z/resource/app/testexport13.rsc *and* in |
|
457 # epoc32/release/winscw/udeb/z/resource/app/testexport13.rsc *and* in |
|
458 # epoc32/release/winscw/urel/z/resource/app/testexport13.rsc |
|
459 self.__testExport(testExports[12], |
|
460 bldInfMakefilePathTestRoot+'bld.infs/testexport13.rsc', |
|
461 '$(EPOCROOT)/epoc32/data/z/resource/app/testexport13.rsc', |
|
462 'copy') |
|
463 |
|
464 self.__testExport(testExports[12], |
|
465 bldInfMakefilePathTestRoot+'bld.infs/testexport13.rsc', |
|
466 '$(EPOCROOT)/epoc32/release/winscw/udeb/z/resource/app/testexport13.rsc', |
|
467 'copy') |
|
468 |
|
469 self.__testExport(testExports[12], |
|
470 bldInfMakefilePathTestRoot+'bld.infs/testexport13.rsc', |
|
471 '$(EPOCROOT)/epoc32/release/winscw/urel/z/resource/app/testexport13.rsc', |
|
472 'copy') |
|
473 |
|
474 |
|
475 def __testExtension(self, aExtensionObject, aMakefile, aTestParameters): |
|
476 |
|
477 templateExtensionRoot = "" |
|
478 |
|
479 if not aMakefile.startswith("$("): |
|
480 templateExtensionRoot = '$(MAKEFILE_TEMPLATES)/' |
|
481 |
|
482 self.assertEquals(aExtensionObject.getMakefile(), templateExtensionRoot+aMakefile) |
|
483 |
|
484 testOptions = aExtensionObject.getOptions() |
|
485 testVariables = aExtensionObject.getStandardVariables() |
|
486 |
|
487 for testParameter in aTestParameters.keys(): |
|
488 if (testParameter.startswith("STDVAR_")): |
|
489 stdvar = testParameter.replace("STDVAR_", "") |
|
490 stdvalue = aTestParameters.get(testParameter) |
|
491 self.assertTrue(testVariables.has_key(stdvar)) |
|
492 self.assertEquals(testVariables.get(stdvar), aTestParameters.get(testParameter)) |
|
493 else: |
|
494 self.assertTrue(testOptions.has_key(testParameter)) |
|
495 self.assertEquals(testOptions.get(testParameter), aTestParameters.get(testParameter)) |
|
496 |
|
497 def testBldInfExtensions(self): |
|
498 bldInfTestRoot = self.__testRoot.Append('metadata/project/bld.infs') |
|
499 bldInfMakefilePathTestRoot = str(self.__makefilePathTestRoot)+'/metadata/project/bld.infs' |
|
500 depfiles = [] |
|
501 bldInfObject = raptor_meta.BldInfFile(bldInfTestRoot.Append('extensions.inf'), |
|
502 self.__gnucpp, depfiles=depfiles, log=self.raptor) |
|
503 |
|
504 extensions = bldInfObject.getExtensions(self.ARMV5) |
|
505 |
|
506 self.__testExtension(extensions[0], |
|
507 'test/dummyextension1.mk', |
|
508 {'TARGET':'dummyoutput1.exe', |
|
509 'SOURCES':'dummysource11.cpp dummysource12.cpp dummysource13.cpp', |
|
510 'DEPENDENCIES':'dummylib11.lib dummylib12.lib', |
|
511 'TOOL':'dummytool1.exe', |
|
512 'OPTION11':'option11value', |
|
513 'OPTION12':'$(MAKE_VAR)', |
|
514 'STDVAR_TO_ROOT':"", |
|
515 'STDVAR_TO_BLDINF':bldInfMakefilePathTestRoot, |
|
516 'STDVAR_EXTENSION_ROOT':bldInfMakefilePathTestRoot} |
|
517 ) |
|
518 |
|
519 self.__testExtension(extensions[1], |
|
520 'test/dummyextension2.mk', |
|
521 {'TARGET':'dummyoutput2.exe', |
|
522 'SOURCES':'dummysource21.cpp dummysource22.cpp dummysource23.cpp', |
|
523 'DEPENDENCIES':'dummylib21.lib dummylib22.lib', |
|
524 'TOOL':'dummytool2.exe', |
|
525 'OPTION21':'option21value', |
|
526 'OPTION22':'$(MAKE_VAR)', |
|
527 'STDVAR_TO_ROOT':"", |
|
528 'STDVAR_TO_BLDINF':bldInfMakefilePathTestRoot, |
|
529 'STDVAR_EXTENSION_ROOT':bldInfMakefilePathTestRoot} |
|
530 ) |
|
531 |
|
532 self.__testExtension(extensions[2], |
|
533 '$(' + raptor.env + ')/test/dummyextension3.mk', |
|
534 {'TARGET':'dummyoutput3.exe', |
|
535 'SOURCES':'dummysource31.cpp dummysource32.cpp dummysource33.cpp', |
|
536 'DEPENDENCIES':'dummylib31.lib dummylib32.lib', |
|
537 'TOOL':'dummytool3.exe', |
|
538 'OPTION31':'option31value', |
|
539 'OPTION32':'$(MAKE_VAR)', |
|
540 'STDVAR_TO_ROOT':"", |
|
541 'STDVAR_TO_BLDINF':bldInfMakefilePathTestRoot, |
|
542 'STDVAR_EXTENSION_ROOT':bldInfMakefilePathTestRoot} |
|
543 ) |
|
544 |
|
545 testExtensions = bldInfObject.getTestExtensions(self.ARMV5) |
|
546 |
|
547 self.__testExtension(testExtensions[0], |
|
548 'test/dummytestextension1.mk', |
|
549 {'TARGET':'dummytestoutput1.exe', |
|
550 'SOURCES':'dummytestsource11.cpp dummytestsource12.cpp dummytestsource13.cpp', |
|
551 'DEPENDENCIES':'dummytestlib11.lib dummytestlib12.lib', |
|
552 'TOOL':'dummytesttool1.exe', |
|
553 'OPTIONTEST11':'optiontest11value', |
|
554 'OPTIONTEST12':'$(MAKE_VAR)', |
|
555 'STDVAR_TO_ROOT':"", |
|
556 'STDVAR_TO_BLDINF':bldInfMakefilePathTestRoot, |
|
557 'STDVAR_EXTENSION_ROOT':bldInfMakefilePathTestRoot} |
|
558 ) |
|
559 |
|
560 self.__testExtension(testExtensions[1], |
|
561 'test/dummytestextension2.mk', |
|
562 {'TARGET':'dummytestoutput2.exe', |
|
563 'SOURCES':'dummytestsource21.cpp dummytestsource22.cpp dummytestsource23.cpp', |
|
564 'DEPENDENCIES':'dummytestlib21.lib dummytestlib22.lib', |
|
565 'TOOL':'dummytesttool2.exe', |
|
566 'OPTIONTEST21':'optiontest21value', |
|
567 'OPTIONTEST22':'$(MAKE_VAR)', |
|
568 'STDVAR_TO_ROOT':"", |
|
569 'STDVAR_TO_BLDINF':bldInfMakefilePathTestRoot, |
|
570 'STDVAR_EXTENSION_ROOT':bldInfMakefilePathTestRoot} |
|
571 ) |
|
572 |
|
573 def testBldInfIncludes(self): |
|
574 bldInfTestRoot = self.__testRoot.Append('metadata/project/bld.infs/includes') |
|
575 depfiles=[] |
|
576 bldInfObject = raptor_meta.BldInfFile(bldInfTestRoot.Append('top_level.inf'), |
|
577 self.__gnucpp, depfiles=depfiles, log=self.raptor) |
|
578 Root = str(bldInfTestRoot) |
|
579 |
|
580 mmpFiles = bldInfObject.getMMPList(self.ARMV5) |
|
581 self.assertEquals(len(mmpFiles['mmpFileList']), 3) |
|
582 self.assertEquals(str(mmpFiles['mmpFileList'][0].filename), Root + "/dir3/down_dir.mmp") |
|
583 self.assertEquals(str(mmpFiles['mmpFileList'][1].filename), Root + "/dir1/dir2/up_dir.mmp") |
|
584 self.assertEquals(str(mmpFiles['mmpFileList'][2].filename), Root + "/top_level.mmp") |
|
585 |
|
586 exports = bldInfObject.getExports(self.ARMV5) |
|
587 self.assertEquals(exports[0].getSource(), Root + "/dir3/down_dir_export_source.h") |
|
588 self.assertEquals(exports[1].getSource(), Root + "/dir1/dir2/up_dir_export_source.h") |
|
589 self.assertEquals(exports[2].getSource(), Root + "/top_level_export_source.h") |
|
590 |
|
591 def testMmpIncludes(self): |
|
592 mmpTestRoot = self.__testRoot.Append('metadata/project/mmps/includes') |
|
593 mmpMakefilePathTestRoot = str(self.__makefilePathTestRoot)+'/metadata/project/mmps/includes' |
|
594 |
|
595 depfiles=[] |
|
596 bldInfObject = raptor_meta.BldInfFile(mmpTestRoot.Append('top_level.inf'), |
|
597 self.__gnucpp, depfiles=depfiles, log=self.raptor) |
|
598 |
|
599 mmpFiles = bldInfObject.getMMPList(self.ARMV5) |
|
600 mmpdeps = [] |
|
601 mmpFile = raptor_meta.MMPFile(mmpFiles['mmpFileList'][0].filename, |
|
602 self.__gnucpp, |
|
603 bldInfObject, |
|
604 depfiles=mmpdeps, |
|
605 log=self.raptor) |
|
606 |
|
607 self.assertEquals(str(mmpFile.filename), |
|
608 str(mmpTestRoot.Append("top_level.mmp"))) |
|
609 |
|
610 |
|
611 mmpContent = mmpFile.getContent(self.ARMV5) |
|
612 mmpBackend = raptor_meta.MMPRaptorBackend(None, str(mmpFile.filename), str(bldInfObject.filename)) |
|
613 mmpParser = mmpparser.MMPParser(mmpBackend) |
|
614 parseresult = None |
|
615 try: |
|
616 parseresult = mmpParser.mmp.parseString(mmpContent) |
|
617 except Exception,e: |
|
618 pass |
|
619 |
|
620 self.assertTrue(parseresult) |
|
621 self.assertEquals(parseresult[0],'MMP') |
|
622 |
|
623 mmpBackend.finalise(self.ARMV5) |
|
624 |
|
625 var = mmpBackend.BuildVariant |
|
626 |
|
627 sources = [] |
|
628 for i in var.ops: |
|
629 if i.name == "SOURCE": |
|
630 sources.extend(i.value.split(" ")) |
|
631 |
|
632 self.assertTrue((mmpMakefilePathTestRoot+'/top_level.cpp') in sources) |
|
633 self.assertTrue((mmpMakefilePathTestRoot+'/dir1/dir2/up_dir.cpp') in sources) |
|
634 self.assertTrue((mmpMakefilePathTestRoot+'/dir3/down_dir.cpp') in sources) |
|
635 |
|
636 |
|
637 def testDefFileResolution(self): |
|
638 |
|
639 class DefFileTest(object): |
|
640 """ Test resolveDefFile for a particular set of mmp options """ |
|
641 def __init__(self, resolveddeffile, mmpfilename, deffilekeyword, target, nostrictdef, platform): |
|
642 self.resolveddeffile = resolveddeffile |
|
643 self.mmpfilename=mmpfilename |
|
644 self.deffilekeyword=deffilekeyword |
|
645 self.target=target |
|
646 self.nostrictdef = nostrictdef |
|
647 self.platform = platform |
|
648 |
|
649 def test(self, raptor): |
|
650 m = raptor_meta.MMPRaptorBackend(raptor, self.mmpfilename, "") |
|
651 m.deffile = self.deffilekeyword |
|
652 m.nostrictdef = self.nostrictdef |
|
653 f = m.resolveDefFile(self.target, self.platform) |
|
654 |
|
655 return path_compare_notdrivelettercase(self.resolveddeffile,f) |
|
656 |
|
657 defFileTests = [] |
|
658 |
|
659 for testPlat in self.testPlats: |
|
660 epocroot = str(testPlat['EPOCROOT']) |
|
661 releaseDir = testPlat['PLATFORM'].lower() |
|
662 defFileDir = "eabi" |
|
663 if testPlat['PLATFORM'] == "WINSCW": |
|
664 defFileDir = "bwins" |
|
665 |
|
666 defFileTests.extend([ |
|
667 DefFileTest( |
|
668 self.__OSRoot+'/test/'+defFileDir+'/targetu.def', |
|
669 '/test/component/mmpfile.mmp', |
|
670 '', |
|
671 'target.exe', |
|
672 False, |
|
673 testPlat), |
|
674 DefFileTest( |
|
675 self.__OSRoot+'/test/'+defFileDir+'/target.def', |
|
676 '/test/component/mmpfile.mmp', |
|
677 '', |
|
678 'target.exe', |
|
679 True, |
|
680 testPlat), |
|
681 DefFileTest( |
|
682 self.__OSRoot+'/test/'+defFileDir+'/targetu.DEF', |
|
683 '/test/component/mmpfile.mmp', |
|
684 'target.DEF', |
|
685 'target.exe', |
|
686 False, |
|
687 testPlat), |
|
688 DefFileTest( |
|
689 self.__OSRoot+'/test/'+defFileDir+'/target2.DEF', |
|
690 '/test/component/mmpfile.mmp', |
|
691 'target2.DEF', |
|
692 'target.exe', |
|
693 True, |
|
694 testPlat), |
|
695 DefFileTest( |
|
696 self.__OSRoot+'/test/component/target2u.DEF', |
|
697 '/test/component/mmpfile.mmp', |
|
698 './target2.DEF', |
|
699 'target.exe', |
|
700 False, |
|
701 testPlat), |
|
702 DefFileTest( |
|
703 self.__OSRoot+'/test/component/target2.DEF', |
|
704 '/test/component/mmpfile.mmp', |
|
705 './target2.DEF', |
|
706 'target.exe', |
|
707 True, |
|
708 testPlat), |
|
709 DefFileTest( |
|
710 self.__OSRoot+'/test/component/'+defFileDir+'/target3u.DEF', |
|
711 '/test/component/mmpfile.mmp', |
|
712 './~/target3.DEF', |
|
713 'target.exe', |
|
714 False, |
|
715 testPlat), |
|
716 DefFileTest( |
|
717 epocroot+'/epoc32/include/def/'+defFileDir+'/targetu.def', |
|
718 '/test/component/mmpfile.mmp', |
|
719 '/epoc32/include/def/~/target.def', |
|
720 'target.exe', |
|
721 False, |
|
722 testPlat), |
|
723 DefFileTest( |
|
724 epocroot+'/epoc32/release/'+releaseDir+'/target.def', |
|
725 '/test/component/mmpfile.mmp', |
|
726 '/epoc32/release/'+releaseDir+'/target.def', |
|
727 'target.exe', |
|
728 True, |
|
729 testPlat), |
|
730 DefFileTest( |
|
731 self.__OSRoot+'/deffiles/targetu.def', |
|
732 '/test/component/mmpfile.mmp', |
|
733 '/deffiles/target.def', |
|
734 'target.exe', |
|
735 False, |
|
736 testPlat) |
|
737 ]) |
|
738 |
|
739 for t in defFileTests: |
|
740 result = t.test(self.raptor) |
|
741 self.assertEquals(result, True) |
|
742 |
|
743 def dummyMetaReader(self): |
|
744 "make raptor_meta.MetaReader.__init__ into a none operation" |
|
745 self.savedInit = raptor_meta.MetaReader.__init__ |
|
746 |
|
747 def DummyMetaReaderInit(self, aRaptor): |
|
748 self._MetaReader__Raptor = aRaptor |
|
749 |
|
750 raptor_meta.MetaReader.__init__ = DummyMetaReaderInit |
|
751 |
|
752 def restoreMetaReader(self): |
|
753 "make raptor_meta.MetaReader.__init__ operational again" |
|
754 raptor_meta.MetaReader.__init__ = self.savedInit |
|
755 |
|
756 def testApplyOsVariant(self): |
|
757 self.dummyMetaReader() |
|
758 |
|
759 # Mock output class |
|
760 class OutputMock(object): |
|
761 def write(self, text): |
|
762 pass |
|
763 |
|
764 bu = raptor_data.BuildUnit("os_variant", []) |
|
765 |
|
766 self.raptor.keepGoing = False |
|
767 |
|
768 metaReader = raptor_meta.MetaReader(self.raptor) |
|
769 metaReader.ApplyOSVariant(bu, ".") |
|
770 |
|
771 self.raptor.keepGoing = True |
|
772 self.raptor.out = OutputMock() |
|
773 metaReader = raptor_meta.MetaReader(self.raptor) |
|
774 metaReader.ApplyOSVariant(bu, ".") |
|
775 |
|
776 self.restoreMetaReader() |
|
777 |
|
778 def __assertEqualStringList(self, aListOne, aListTwo): |
|
779 self.assertEquals(len(aListOne), len(aListTwo)) |
|
780 |
|
781 i = 0 |
|
782 while i < len(aListOne) : |
|
783 self.assertEquals(aListOne[i], aListTwo[i]) |
|
784 i = i + 1 |
|
785 |
|
786 def testOptionReplace(self): |
|
787 # Test how we resolve known permutations of values given to the .mmp file OPTION_REPLACE keyword |
|
788 mockBackend = raptor_meta.MMPRaptorBackend(self.raptor, "somefile.mmp", "") |
|
789 |
|
790 results = mockBackend.resolveOptionReplace('--argA') |
|
791 self.__assertEqualStringList(results, ['--argA<->']) |
|
792 |
|
793 results = mockBackend.resolveOptionReplace('--argB value') |
|
794 self.__assertEqualStringList(results, ['--argB%20<->@@', '@@%<->--argB%20value']) |
|
795 |
|
796 results = mockBackend.resolveOptionReplace('--argD value1 --argE') |
|
797 self.__assertEqualStringList(results, ['--argD%20<->@@', '@@%<->--argD%20value1', '--argE<->']) |
|
798 |
|
799 results = mockBackend.resolveOptionReplace('--argF --argG') |
|
800 self.__assertEqualStringList(results, ['--argF<->--argG']) |
|
801 |
|
802 results = mockBackend.resolveOptionReplace('--argH --argI value') |
|
803 self.__assertEqualStringList(results, ['--argH<->--argI%20value']) |
|
804 |
|
805 results = mockBackend.resolveOptionReplace('--argJ value1 --argK value2') |
|
806 self.__assertEqualStringList(results, ['--argJ%20<->@@', '@@%<->--argJ%20value1', '--argK%20<->@@', '@@%<->--argK%20value2']) |
|
807 |
|
808 results = mockBackend.resolveOptionReplace('--argL value1 --argM value2 --argN --argO') |
|
809 self.__assertEqualStringList(results, ['--argL%20<->@@', '@@%<->--argL%20value1', '--argM%20<->@@', '@@%<->--argM%20value2', '--argN<->--argO']) |
|
810 |
|
811 results = mockBackend.resolveOptionReplace('--argP value1 value2 --argQ value3 value4') |
|
812 self.__assertEqualStringList(results, ['--argP%20<->@@', '@@%<->--argP%20value1', '--argQ%20<->@@', '@@%<->--argQ%20value3']) |
|
813 |
|
814 results = mockBackend.resolveOptionReplace('value1 value2') |
|
815 self.__assertEqualStringList(results, []) |
|
816 |
|
817 results = mockBackend.resolveOptionReplace('value1 --argR') |
|
818 self.__assertEqualStringList(results, ['--argR<->']) |
|
819 |
|
820 results = mockBackend.resolveOptionReplace('-singleHyphenargS value1 -singleHyphenargT value2') |
|
821 self.__assertEqualStringList(results, ['-singleHyphenargS%20<->@@', '@@%<->-singleHyphenargS%20value1', '-singleHyphenargT%20<->@@', '@@%<->-singleHyphenargT%20value2']) |
|
822 |
|
823 results = mockBackend.resolveOptionReplace('--assignmentArgU=value1 --assignmentArgV=value2') |
|
824 self.__assertEqualStringList(results, ['--assignmentArgU=value1<->--assignmentArgV=value2']) |
|
825 |
|
826 def testModuleName(self): |
|
827 self.dummyMetaReader() |
|
828 |
|
829 # Test how we resolve known permutations of values given to the .mmp file OPTION_REPLACE keyword |
|
830 mockBackend = raptor_meta.MetaReader(self.raptor) |
|
831 |
|
832 resultsDictList = [ {"bldinf":"Z:/src/romfile/group/tb92/GROUP/bld.inf", "result":"romfile"}, |
|
833 {"bldinf":"/src/romfile/group/tb92/GROUP/bld.inf", "result":"romfile"}, |
|
834 {"bldinf":"Z:/src/romFile/group/tb92/GROUP/another.inf", "result":"romFile"}, |
|
835 {"bldinf":"X:/src/RoMfile/group/bld.inf", "result":"RoMfile"}, |
|
836 {"bldinf":"w:/contacts/group/ONgoing/group/bld.inf", "result":"contacts"}, |
|
837 {"bldinf":"p:/group/bld.inf", "result":"module"}, |
|
838 {"bldinf":"/group/bld.inf", "result":"module"}, |
|
839 {"bldinf":"p:/ONGOING/bld.inf", "result":"module"}, |
|
840 {"bldinf":"/ONGOING/bld.inf", "result":"module"} |
|
841 ] |
|
842 |
|
843 for result in resultsDictList: |
|
844 moduleName = mockBackend.ModuleName(result["bldinf"]) |
|
845 self.assertEquals(moduleName, result["result"]) |
|
846 |
|
847 self.restoreMetaReader() |
|
848 |
|
849 |
|
850 def path_compare_notdrivelettercase(aRequirement, aCandidate): |
|
851 if sys.platform.startswith("win"): |
|
852 if aRequirement[1] == ":": |
|
853 aRequirement = aRequirement[0].lower() + aRequirement[1:] |
|
854 aCandidate = aCandidate[0].lower() + aCandidate[1:] |
|
855 |
|
856 return aRequirement == aCandidate |
|
857 |
|
858 |
|
859 # run all the tests |
|
860 |
|
861 from raptor_tests import SmokeTest |
|
862 |
|
863 def run(): |
|
864 t = SmokeTest() |
|
865 t.id = "999" |
|
866 t.name = "raptor_meta_unit" |
|
867 |
|
868 tests = unittest.makeSuite(TestRaptorMeta) |
|
869 result = unittest.TextTestRunner(verbosity=2).run(tests) |
|
870 |
|
871 if result.wasSuccessful(): |
|
872 t.result = SmokeTest.PASS |
|
873 else: |
|
874 t.result = SmokeTest.FAIL |
|
875 |
|
876 return t |