Package ats3 :: Module parsers
[hide private]
[frames] | no frames]

Source Code for Module ats3.parsers

  1  # -*- encoding: latin-1 -*- 
  2   
  3  #============================================================================  
  4  #Name        : parsers.py  
  5  #Part of     : Helium  
  6   
  7  #Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
  8  #All rights reserved. 
  9  #This component and the accompanying materials are made available 
 10  #under the terms of the License "Eclipse Public License v1.0" 
 11  #which accompanies this distribution, and is available 
 12  #at the URL "http://www.eclipse.org/legal/epl-v10.html". 
 13  # 
 14  #Initial Contributors: 
 15  #Nokia Corporation - initial contribution. 
 16  # 
 17  #Contributors: 
 18  # 
 19  #Description: 
 20  #=============================================================================== 
 21   
 22  """ The ATS related parsers """ 
 23   
 24   
 25  #w0142 => * and ** were used 
 26  #F0401 => pylint didn't find "path" module 
 27  #C0302 => Too many lines 
 28   
 29   
 30  import os 
 31  import re 
 32  import sys 
 33  import string 
 34  import logging 
 35  from path import path 
 36  from textwrap import dedent 
 37  import fnmatch 
 38  import subprocess 
 39  import codecs 
 40   
 41  _logger = logging.getLogger('ats3') 
 42   
 43  import configuration 
44 -def split_config_to_attributes_and_properties(specfile):
45 """Split the specfile to its parts""" 46 attributes = {} 47 properties = {} 48 builder = configuration.NestedConfigurationBuilder(specfile) 49 configs = builder.getConfigurations() 50 # the supported configs are either attributes or properties 51 # collect each in a dictionary and return them. 52 for config in configs: 53 if config.name == 'attributes' : 54 for attr in config: 55 attributes[attr] = config[attr] 56 if config.name == 'properties' : 57 for prop in config: 58 properties[prop] = config[prop] 59 return (properties, attributes)
60 61
62 -class CppParser(object):
63 """ 64 Parser for CPP tool output. Returns cleaned output from the execution 65 of CPP with or without parent paths included in the output. 66 """ 67
68 - def __init__(self):
69 pass
70
71 - def get_cpp_output(self, bld_path = None, output_parameter = "n", imacros = None):
72 """ 73 To clean out conditionals from the compilation it is necessary to 74 use C preprocessing to clean out those. 75 76 If ('n' - normal) output is chosen, parser returns list of paths 77 If ('e' - extended) output is chosen parser returns list of (path, parent_path) tuples 78 If ('d' - dependency) output is chosen parser returns a dicitionary (can be a nested dictionary) 79 of paths dependency (-ies). 80 81 'imacros' can also be given as parameters for CPP options. 82 83 if bld file is not given, the function will try to find the file(s) on the given location with extension ".inf" 84 """ 85 86 clean_path_list = [] 87 path_list = [] 88 temp_path = os.getcwd() 89 if "bld.inf" in str(bld_path).lower(): 90 os.chdir(os.path.normpath(os.path.join(bld_path, os.pardir))) 91 else: 92 os.chdir(os.path.normpath(os.path.join(bld_path))) 93 if imacros is not None: 94 command = u"cpp -imacros %s bld.inf" % str(imacros) 95 else: 96 command = u"cpp bld.inf" 97 process = subprocess.Popen(command, shell = True, stdout = subprocess.PIPE) 98 pipe = process.stdout 99 100 if output_parameter == "d": 101 return self.create_dependency_dictionary(pipe, bld_path) 102 103 for line in pipe.readlines(): 104 if re.search(r"\A#\s.*?", line.strip()) or re.search(r"\A#.*?[0-9]", line.strip()): 105 if line.strip() not in path_list: 106 path_list.append(line.strip()) 107 process.wait() 108 if process.returncode == 1: 109 _logger.error('CPP failed: ' + command + ' in: ' + os.getcwd()) 110 pipe.close() 111 112 os.chdir(temp_path) 113 if output_parameter is "n": 114 for _path in self.clean_cpp_output(bld_path, path_list): 115 clean_path_list.append(_path[0]) 116 elif output_parameter is "e": 117 clean_path_list = self.clean_cpp_output(bld_path, path_list) 118 119 clean_path_list = list(set(clean_path_list)) 120 121 bfp = BldFileParser() 122 123 for tsrc in clean_path_list: 124 mmp_path = bfp.get_test_mmp_files(tsrc[0]) 125 if tsrc[0] == tsrc[1]: 126 if mmp_path == None or mmp_path == []: 127 clean_path_list.remove(tsrc) 128 129 return clean_path_list
130
131 - def create_dependency_dictionary(self, _pipe_, path_to_bld):
132 """ 133 The output from CPP is cleaned in a fashion that the output is 134 a dictionary (or nested dictionary) of paths and their dependencies. 135 """ 136 bld_parser = BldFileParser() 137 pkg_parser = PkgFileParser() 138 mmp_parser = MmpFileParser() 139 140 temp_path = os.getcwd() 141 parent = os.getcwd() 142 self.path_to_bld = path_to_bld 143 test_case = {} 144 test_sets = {} 145 harness = "" 146 main_level = "" 147 test_case = [] 148 test_cases = [] 149 output_list = [] 150 151 for line in _pipe_.readlines(): 152 if re.match(r"#.*", line.lower()): 153 path_var = re.findall(r'(.?bld.inf.?)', line.lower()) 154 output_list.append((line, os.path.dirname(os.path.normpath(os.path.join(self.path_to_bld, re.findall(r'"(.*bld.inf?)"', line.lower())[0]))))) 155 _pipe_.close() 156 os.chdir(temp_path) 157 158 #Creating dependencies 159 for case in output_list: 160 temp_test_case = test_case 161 if re.match(r".*[bld.inf][^0-9]\Z", string.strip(string.lower(case[0]))): 162 main_level = case[1] 163 parent = case[1] 164 os.chdir(case[1]) 165 mmp_files = [] 166 dlls = {} 167 test_cases.append((parent, case[1])) 168 elif re.match(r".*[1]\Z", string.strip(string.lower(case[0]))): 169 parent = os.getcwd() 170 os.chdir(case[1]) 171 mmp_files = [] 172 dlls = {} 173 test_files = False 174 test_cases.append((parent, case[1])) 175 elif re.match(r".*[2]\Z", string.strip(string.lower(case[0]))): 176 if test_cases: 177 for tcase in test_cases: 178 if parent in tcase[1]: 179 parent = tcase[0] 180 os.chdir(tcase[1]) 181 break 182 183 for t_case in test_cases: 184 if t_case[0] == t_case[1]: 185 del t_case 186 elif t_case[0] in main_level: 187 test_sets[t_case[1]] = {} 188 test_sets[t_case[1]]['content'] = {} 189 test_sets[t_case[1]]['content'][t_case[1]] = {} 190 harness = mmp_parser.get_harness(t_case[1]) 191 #if harness == "": harness = None 192 test_sets[t_case[1]]['content'][t_case[1]]['type'] = mmp_parser.get_dll_type(t_case[1]) 193 test_sets[t_case[1]]['content'][t_case[1]]['harness'] = harness 194 test_sets[t_case[1]]['content'][t_case[1]]['pkg_files'] = pkg_parser.get_pkg_files(t_case[1], False) 195 test_sets[t_case[1]]['content'][t_case[1]]['mmp_files'] = bld_parser.get_test_mmp_files(t_case[1], False) 196 else: 197 for key, value in test_sets.items(): 198 if t_case[0] in value['content'].keys(): 199 harness = mmp_parser.get_harness(t_case[1]) 200 if harness is "" or harness in test_sets[key]['content'][t_case[0]]['harness']: 201 test_sets[key]['content'][t_case[1]] = {} 202 test_sets[key]['content'][t_case[1]]['type'] = mmp_parser.get_dll_type(t_case[1]) 203 test_sets[key]['content'][t_case[1]]['harness'] = harness 204 test_sets[key]['content'][t_case[1]]['pkg_files'] = pkg_parser.get_pkg_files(t_case[1], False) 205 test_sets[key]['content'][t_case[1]]['mmp_files'] = bld_parser.get_test_mmp_files(t_case[1], False) 206 else: 207 test_sets[t_case[1]] = {} 208 test_sets[t_case[1]]['content'] = {} 209 test_sets[t_case[1]]['content'][t_case[1]] = {} 210 test_sets[t_case[1]]['content'][t_case[1]]['type'] = mmp_parser.get_dll_type(t_case[1]) 211 test_sets[t_case[1]]['content'][t_case[1]]['harness'] = harness 212 test_sets[t_case[1]]['content'][t_case[1]]['pkg_files'] = pkg_parser.get_pkg_files(t_case[1], False) 213 test_sets[t_case[1]]['content'][t_case[1]]['mmp_files'] = bld_parser.get_test_mmp_files(t_case[1], False) 214 215 return test_sets
216 217
218 - def clean_cpp_output(self, bld_path, path_list):
219 """ 220 The output from CPP needs to be "cleaned" so that extra chars needs 221 to be removed and also hierarchy which cpp is following is preserved 222 and returned as an output. 223 """ 224 225 pat = "" 226 value = "" 227 cleaned_output = [] 228 if "bld.inf" in bld_path: 229 path_to_parent = os.path.dirname(bld_path) 230 else: 231 path_to_parent = bld_path 232 pat = re.compile(r'\A#\s*?.*?[\"](.*?)[\"].*?') 233 for _path in path_list: 234 if re.match(r".*[bld.inf]\s*?[^0-9]\Z", string.strip(string.lower(_path))): 235 value = pat.match(_path.strip()) 236 path_to_tc = os.path.dirname(os.path.normpath(os.path.join((bld_path), value.group(1)))) 237 cleaned_output.append((path_to_tc, path_to_parent)) 238 if re.match(r".*[1]\s*?\Z", string.strip(string.lower(_path))): 239 value = pat.match(_path.strip()) 240 path_to_tc = os.path.dirname(os.path.normpath(os.path.join(bld_path, value.group(1)))) 241 cleaned_output.append((path_to_tc, path_to_parent)) 242 if re.match(r".*[2]\s*?\Z", string.strip(string.lower(_path))): 243 if cleaned_output: 244 for cout in cleaned_output: 245 if string.lower(path_to_parent) == string.lower(cout[0]): 246 path_to_tc = cout[1] 247 path_to_parent = path_to_tc 248 return cleaned_output
249 250
251 -class BldFileParser(object):
252 """ 253 Parser for bld.inf files. Returns MACRO values. 254 Parsing Paths can be done using CPP parser 255 """
256 - def __init__(self):
257 pass
258 259 #def get_mmp_files(): 260 # """ 261 # returns mmp files from PRJ_MMPFILES macro 262 # """ 263
264 - def get_test_mmp_files(self, bld_file_path = None, with_full_path = True):
265 """ 266 returns a list of test mmp files 267 Usage: if "x:\abc\bldfile", "PRJ_TESTMMPFILES". 268 1. get_test_mmp_files("x:\abc\bldfile") - with full paths e.g. ["x:\abc\abc.mmp"] 269 2. get_test_mmp_files("x:\abc\bldfile", False) - without full paths e.g. ["abc.mmp"] 270 271 if bld file is not given, the function will try to find the file(s) on the given location with extension ".inf" 272 """ 273 274 if bld_file_path == None: 275 _logger.warning("Incorrect bld file") 276 return None 277 else: 278 self.bld_file_path = path(bld_file_path) 279 if not "bld.inf" in str(self.bld_file_path).lower(): 280 self.bld_file_path = os.path.join(os.path.normpath(self.bld_file_path), "bld.inf") 281 282 if not os.path.exists(self.bld_file_path): 283 _logger.error(r"bld file path does not exist: '%s'" % self.bld_file_path) 284 return None 285 286 return self.get_files(path(self.bld_file_path), "PRJ_TESTMMPFILES", with_full_path)
287 288
289 - def get_files(self, bld_inf_path, bld_macro, with_full_path = True):
290 """ 291 Component's MMP files, as stored in BLD.INF. 292 """ 293 294 mmp_files = [] 295 self.bld_inf_path = path(bld_inf_path) 296 bld_inf = self.bld_inf_path.text() 297 try: 298 bld_inf = re.compile(r"%s" % bld_macro).split(bld_inf)[1].strip() 299 bld_inf = re.compile(r"PRJ_+\S").split(bld_inf)[0].strip() 300 301 except IndexError: 302 try: 303 bld_inf = re.compile(r"%s" % bld_macro).split(bld_inf)[0].strip() 304 bld_inf = re.compile(r"PRJ_+\S").split(bld_inf)[0].strip() 305 306 except IndexError: 307 _logger.warning("Index Error while parsing bld.inf file") 308 309 comments_free_text = self.ignore_comments_from_input(bld_inf) 310 311 mmp_files = re.findall(r"(\S+?[.]mmp)", comments_free_text) 312 313 314 315 if with_full_path: 316 self.bld_dir = self.bld_inf_path.dirname() 317 return [path.joinpath(self.bld_dir, mmp).normpath() 318 for mmp in mmp_files] 319 else: 320 return mmp_files
321
322 - def ignore_comments_from_input(self, input_str = ""):
323 """ 324 Removes comments from the input string. Enables the use of examples 325 in bld.inf. 326 """ 327 _input = "" 328 for i in input_str.split("\n"): 329 _input += "\n" + i.split("//")[0] 330 331 if not _input == "": 332 input_str = _input 333 count = input_str.count("/*") 334 count2 = input_str.count("*/") 335 if (count == count2): 336 idx_1 = input_str.find('/*') 337 idx_2 = input_str.find('*/') + 2 338 while count > 0: 339 substr_1 = input_str[:idx_1].strip() 340 substr_2 = input_str[idx_2:].strip() 341 input_str = substr_1 + " " + substr_2 342 idx_1 = input_str.find('/*') 343 idx_2 = input_str.find('*/') + 2 344 count = input_str.count('/*') 345 return input_str.strip() 346 else: 347 _logger.warning("Comments in bld.inf-file inconsistent. " 348 "Check comments in bld.inf.") 349 return input_str.strip()
350 351 352 #def get_exports(): 353 # """ 354 # returns exports from the macro PRJ_EXPORTS 355 # """ 356
357 -class MmpFileParser(object):
358 """ 359 Parser for .mmp files. Returns wanted information from the mmp-file 360 - file type (executable dll, plugin, exe, etc) 361 - test harness (STIF, EUNIT) if mmp is related to the test component 362 - file name 363 - libraries listed in the mmp 364 """ 365
366 - def __init__(self):
367 pass
368
369 - def get_target_filetype(self, path_to_mmp = None):
370 """ 371 Filetype given using TARGETTYPE in .mmp file is returned. 372 If "c:\path\to\mmp" is a location where mmp file is stored 373 get_target_filetype("c:\path\to\mmp") 374 375 if mmp file is not given, the function will try to find the file(s) on the given location with extension ".mmp" 376 """ 377 return self.read_information_from_mmp(path_to_mmp, 4)
378
379 - def get_target_filename(self, path_to_mmp = None):
380 """ 381 Filename given using TARGET in .mmp file is returned 382 If "c:\path\to\mmp" is a location where mmp file is stored 383 get_target_filename("c:\path\to\mmp") 384 385 if mmp file is not given, the function will try to find the file(s) on the given location with extension ".mmp" 386 """ 387 return self.read_information_from_mmp(path_to_mmp, 3)
388
389 - def get_libraries(self, path_to_mmp = None):
390 """ 391 Libraries listed in the MMP file are returned in a list 392 If "c:\path\to\mmp" is a location where mmp file is stored 393 get_libraries("c:\path\to\mmp") 394 395 if mmp file is not given, the function will try to find the file(s) on the given location with extension ".mmp" 396 """ 397 return self.read_information_from_mmp(path_to_mmp, 5)
398
399 - def get_harness(self, path_to_mmp = None):
400 """ 401 Returns harness of test component 402 If "c:\path\to\mmp" is a location where mmp file is stored 403 get_harness("c:\path\to\mmp") 404 405 if mmp file is not given, the function will try to find the file(s) on the given location with extension ".mmp" 406 """ 407 return self.read_information_from_mmp(path_to_mmp, 6)
408
409 - def get_dll_type(self, path_to_mmp = None):
410 """ 411 Returns type of test whether 'executable' or 'dependent' (dependent can be a stub or plugin) 412 If "c:\path\to\mmp" is a location where mmp file is stored 413 get_dll_type("c:\path\to\mmp") 414 415 if mmp file is not given, the function will try to find the file(s) on the given location with extension ".mmp" 416 """ 417 return self.read_information_from_mmp(path_to_mmp, 7)
418
419 - def read_information_from_mmp(self, path_to_mmp = None, flag = 0):
420 """ 421 Returns wanted information - user can define 422 the wanted information level by setting a flag 423 value following way: 424 0 - (targetfilename, filetype, libraries, harness) 425 1 - (targetfilename, filetype, libraries) 426 2 - (targetfilename, filetype) 427 3 - targetfilename 428 4 - filetype 429 5 - libraries 430 6 - harness (in case of test component) 431 7 - mmpfilename 432 """ 433 434 435 filename = "" 436 filetype = "" 437 dll_type = "" 438 libraries = [] 439 self.mmp_files = [] 440 lst_mmp_paths = [] 441 harness = "" 442 stif = False 443 eunit = False 444 stifunit = False 445 self.path_to_mmp = path_to_mmp 446 try: 447 448 self.path_to_mmp = path(self.path_to_mmp) 449 if not ".mmp" in str(self.path_to_mmp).lower(): 450 bld_parser = BldFileParser() 451 self.mmp_files = bld_parser.get_test_mmp_files(self.path_to_mmp, False) 452 453 for mpath in self.mmp_files: 454 lst_mmp_paths.append(os.path.join(self.path_to_mmp, mpath)) 455 else: 456 lst_mmp_paths.append(self.path_to_mmp) 457 458 for mmp in lst_mmp_paths: 459 mmp_file = open(mmp, 'r') 460 for line in mmp_file: 461 if re.match(r"\A(target\s).*([.]\w+)", string.strip(string.lower(line))): 462 filename = re.findall(r"\Atarget[\s]*(\w+[.]\w+)", string.lower(line))[0] 463 elif re.match(r"\A(targettype\s).*", string.strip(string.lower(line))): 464 filetype = re.findall(r"\Atargettype[\s]*(\w+)", string.lower(line))[0] 465 466 libraries = re.findall(r"\b(\w+[.]lib)\b", mmp.text().lower()) 467 468 if libraries: 469 if "stiftestinterface.lib" in libraries: 470 stif = True 471 if "eunit.lib" in libraries or "qttest.lib" in libraries: 472 eunit = True 473 if "stifunit.lib" in libraries: 474 stifunit = True 475 476 if stif and eunit: 477 #_logger.warning("both eunit.lib and stiftestinterface.lib listed in mmp file - choosing STIF.") 478 harness = "STIF" 479 elif stif and not eunit: 480 harness = "STIF" 481 elif eunit and not stif: 482 harness = "EUNIT" 483 elif stifunit and not stif and not eunit: 484 harness = "STIFUNIT" 485 486 if harness is "": 487 dll_type = "dependent" 488 elif harness is "EUNIT": 489 dll_type = "executable" 490 elif harness is "STIF": 491 dll_type = "executable" 492 493 494 finally: 495 if flag == 0: 496 return (filename, filetype, libraries, harness) 497 elif flag == 1: 498 return (filename, filetype, libraries) 499 elif flag == 2: 500 return (filename, filetype) 501 elif flag == 3: 502 return filename 503 elif flag == 4: 504 return filetype 505 elif flag == 5: 506 return libraries 507 elif flag == 6: 508 return harness 509 elif flag == 7: 510 return dll_type
511
512 -class PkgFileParser(object):
513 """ 514 Parses .pkg files. Returns a list of: 515 a. src path of the file 516 b. dst path on the phone 517 c. type of the file 518 for every file in the pkg file 519 """ 520
521 - def __init__(self, platform = None):
522 self.platform = platform
523
524 - def get_pkg_files(self, location = None, with_full_path = True):
525 """ 526 Returns list of PKG files on the given location. If True, full path is returned 527 otherwise only filenames. Default is set to True 528 529 Assume at location "c:\abd\files", two pkg file '1.pkg' and '2.pkg', then the funtion 530 can be called as: 531 1. get_pkg_files("c:\abd\files") - will return a list of pkg files with full paths. 532 like ['c:\abd\files\1.pkg', 'c:\abd\files\2.pkg'] 533 2. get_pkg_files("c:\abd\files", False) - will return a list of pkg files only. 534 like ['1.pkg', '2.pkg'] 535 """ 536 self.location = path(location) 537 self.pkg_files = [] 538 if not self.location.exists(): 539 return None 540 541 for p, subdirs, files in os.walk(self.location): 542 pfiles = [f for f in files if self.platform != None and f.endswith(self.platform)] 543 if self.platform != None and len(pfiles)>0: 544 if with_full_path: 545 self.pkg_files.append(os.path.join(p, pfiles[0])) 546 else: 547 self.pkg_files.append(str(pfiles[0])) 548 else: 549 for name in files: 550 if fnmatch.fnmatch(name, "*.pkg"): 551 if with_full_path: 552 self.pkg_files.append(os.path.join(p, name)) 553 else: 554 self.pkg_files.append(str(name)) 555 556 return self.pkg_files
557
558 - def get_data_files(self, location = [], drive = "", exclude = ""):
559 """ 560 Returns data files, source and destination of the files to be installed 561 on the phone 562 e.g. location = tsrc\testComponent\group 563 564 Function can be called in any of the following ways: 565 1. get_data_files("c:\abc\abc.pkg") - only data files' paths are returnd 566 as they are mention in the pkg file 567 2. get_data_files("c:\abc\abc.pkg", "x:") - Proper data files' paths are returnd 568 with drive letter included 569 3. get_data_files("c:\abc\abc.pkg", "x:", "\.dll") - Data files' paths are returnd with 570 drive letter included but the dll 571 files will be excluded if found in 572 the pkg file 573 574 if pkg file is not given, the function will try to find the file(s) on the given location with extension ".pkg" 575 """ 576 577 self.drive = drive 578 self.exclude = exclude 579 self._files = [] 580 581 if type(location) is not list: 582 locations = [location] 583 else: 584 locations = location 585 586 for _file_ in locations: 587 588 #if location is already a file 589 if ".pkg" in str(_file_).lower(): 590 self._files = _file_ 591 else: 592 self.location = path(_file_) 593 594 if not self.location.exists(): 595 continue 596 for p_file in self.get_pkg_files(self.location, True): 597 self._files.append(p_file) 598 599 return self.__read_pkg_file(self._files)
600
601 - def __map_pkg_path(self, pkg_line, pkg_file_path):
602 """Parse package file to get the src and dst paths" for installing files""" 603 mmp_parser = MmpFileParser() 604 ext = "" 605 val1 = "" 606 val2 = "" 607 map_src = "" 608 map_dst = "" 609 self.pkg_file_path = pkg_file_path 610 611 if not self.exclude == "": 612 if re.search(r'%s' % self.exclude, pkg_line) is not None: 613 return None 614 #searches for the file path (src and dst) in the pkg file 615 #e.g.: "..\conf\VCXErrors.inc"-"C:\TestFramework\VCXErrors.inc" 616 result = re.search(r'^\s*"(.*?)".*?-.*?"(.*?)"', pkg_line) 617 618 if result is None: 619 return None 620 val1, val2 = result.groups() 621 622 if val1 != "": 623 if path.isabs(path(val1).normpath()): 624 map_src = str(path.joinpath(self.drive, val1).normpath()) 625 elif re.search(r"\A\w", val1, 1): 626 map_src = str(path.joinpath(self.pkg_file_path + os.sep, os.path.normpath(val1)).normpath()) 627 else: 628 map_src = str(path.joinpath(self.pkg_file_path, path(val1)).normpath()) 629 map_dst = str(path(val2).normpath()) 630 else: 631 map_src, map_dst = val1, val2 632 map_src = map_src.strip() 633 634 #replaces the characters with the drive letters 635 map_dst = map_dst.replace("!:", "c:") 636 map_dst = map_dst.replace("$:", "c:") 637 map_dst = re.sub(r'^(\w)', r'\1', map_dst).strip() 638 indx = map_dst.rsplit(".") 639 try: 640 ext = indx[1] 641 except IndexError: 642 _logger.warning("Index Error in map_pkg_path()") 643 644 _test_type_ = "" 645 _target_filename_ = "" 646 647 _target_filename_ = mmp_parser.get_target_filename(self.pkg_file_path) 648 _test_type_ = mmp_parser.get_dll_type(self.pkg_file_path) 649 _harness_ = mmp_parser.get_harness(self.pkg_file_path) 650 651 if ext == "ini": 652 file_type = "engine_ini" 653 elif ext == "cfg": 654 file_type = "conf" 655 elif ext == "dll": 656 #adding type of dll (executable or dependent), if file type is dll 657 if _test_type_ == "dependent": 658 file_type = "data" + ":%s" % _test_type_ 659 else: 660 file_type = "testmodule" 661 662 elif ext == "exe": 663 if _test_type_ == "dependent": 664 file_type = "data" + ":%s" % _test_type_ 665 else: 666 file_type = "testmodule" 667 668 elif ext == "sisx": 669 file_type = "" 670 elif ext == "xml": 671 file_type = "trace_init" 672 elif ext == "pmd": 673 file_type = "pmd" 674 else: 675 file_type = "data" 676 677 if not map_src or map_src == "." or not map_dst or map_dst == ".": 678 return None 679 680 return path(map_src).normpath(), path(map_dst).normpath(), file_type
681
682 - def __read_pkg_file(self, pkg_files):
683 """Reads contents of PKG file""" 684 pkg_paths = [] 685 for pkg_file in pkg_files: 686 if not os.path.exists( pkg_file ): 687 _logger.error("No PKG -file in path specified") 688 continue 689 else: 690 file1 = codecs.open(pkg_file, 'r', 'utf16') 691 try: 692 lines = file1.readlines() 693 except UnicodeError: 694 file1 = open(pkg_file, 'r') 695 lines = file1.readlines() 696 pkg_file_path = path((pkg_file.rsplit(os.sep, 1))[0]) 697 for line in lines: 698 pkg_path = self.__map_pkg_path(line, pkg_file_path) 699 if pkg_path is None: 700 continue 701 else: 702 pkg_paths.append(pkg_path) 703 704 return pkg_paths
705