|
13
|
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
|