1#!/usr/bin/env python 2 3# Copyright 2008 Rene Rivera 4# Distributed under the Boost Software License, Version 1.0. 5# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) 6 7import re 8import optparse 9import time 10import xml.dom.minidom 11import xml.dom.pulldom 12from xml.sax.saxutils import unescape, escape 13import os.path 14from pprint import pprint 15from __builtin__ import exit 16 17class BuildOutputXMLParsing(object): 18 ''' 19 XML parsing utilities for dealing with the Boost Build output 20 XML format. 21 ''' 22 23 def get_child_data( self, root, tag = None, id = None, name = None, strip = False, default = None ): 24 return self.get_data(self.get_child(root,tag=tag,id=id,name=name),strip=strip,default=default) 25 26 def get_data( self, node, strip = False, default = None ): 27 data = None 28 if node: 29 data_node = None 30 if not data_node: 31 data_node = self.get_child(node,tag='#text') 32 if not data_node: 33 data_node = self.get_child(node,tag='#cdata-section') 34 data = "" 35 while data_node: 36 data += data_node.data 37 data_node = data_node.nextSibling 38 if data_node: 39 if data_node.nodeName != '#text' \ 40 and data_node.nodeName != '#cdata-section': 41 data_node = None 42 if not data: 43 data = default 44 else: 45 if strip: 46 data = data.strip() 47 return data 48 49 def get_child( self, root, tag = None, id = None, name = None, type = None ): 50 return self.get_sibling(root.firstChild,tag=tag,id=id,name=name,type=type) 51 52 def get_sibling( self, sibling, tag = None, id = None, name = None, type = None ): 53 n = sibling 54 while n: 55 found = True 56 if type and found: 57 found = found and type == n.nodeType 58 if tag and found: 59 found = found and tag == n.nodeName 60 if (id or name) and found: 61 found = found and n.nodeType == xml.dom.Node.ELEMENT_NODE 62 if id and found: 63 if n.hasAttribute('id'): 64 found = found and n.getAttribute('id') == id 65 else: 66 found = found and n.hasAttribute('id') and n.getAttribute('id') == id 67 if name and found: 68 found = found and n.hasAttribute('name') and n.getAttribute('name') == name 69 if found: 70 return n 71 n = n.nextSibling 72 return None 73 74class BuildOutputProcessor(BuildOutputXMLParsing): 75 76 def __init__(self, inputs): 77 self.test = {} 78 self.target_to_test = {} 79 self.target = {} 80 self.parent = {} 81 self.timestamps = [] 82 for input in inputs: 83 self.add_input(input) 84 85 def add_input(self, input): 86 ''' 87 Add a single build XML output file to our data. 88 ''' 89 events = xml.dom.pulldom.parse(input) 90 context = [] 91 for (event,node) in events: 92 if event == xml.dom.pulldom.START_ELEMENT: 93 context.append(node) 94 if node.nodeType == xml.dom.Node.ELEMENT_NODE: 95 x_f = self.x_name_(*context) 96 if x_f: 97 events.expandNode(node) 98 # expanding eats the end element, hence walking us out one level 99 context.pop() 100 # call handler 101 (x_f[1])(node) 102 elif event == xml.dom.pulldom.END_ELEMENT: 103 context.pop() 104 105 def x_name_(self, *context, **kwargs): 106 node = None 107 names = [ ] 108 for c in context: 109 if c: 110 if not isinstance(c,xml.dom.Node): 111 suffix = '_'+c.replace('-','_').replace('#','_') 112 else: 113 suffix = '_'+c.nodeName.replace('-','_').replace('#','_') 114 node = c 115 names.append('x') 116 names = map(lambda x: x+suffix,names) 117 if node: 118 for name in names: 119 if hasattr(self,name): 120 return (name,getattr(self,name)) 121 return None 122 123 def x_build_test(self, node): 124 ''' 125 Records the initial test information that will eventually 126 get expanded as we process the rest of the results. 127 ''' 128 test_node = node 129 test_name = test_node.getAttribute('name') 130 test_target = self.get_child_data(test_node,tag='target',strip=True) 131 ## print ">>> %s %s" %(test_name,test_target) 132 self.test[test_name] = { 133 'library' : "/".join(test_name.split('/')[0:-1]), 134 'test-name' : test_name.split('/')[-1], 135 'test-type' : test_node.getAttribute('type').lower(), 136 'test-program' : self.get_child_data(test_node,tag='source',strip=True), 137 'target' : test_target, 138 'info' : self.get_child_data(test_node,tag='info',strip=True), 139 'dependencies' : [], 140 'actions' : [], 141 } 142 # Add a lookup for the test given the test target. 143 self.target_to_test[self.test[test_name]['target']] = test_name 144 return None 145 146 def x_build_targets_target( self, node ): 147 ''' 148 Process the target dependency DAG into an ancestry tree so we can look up 149 which top-level library and test targets specific build actions correspond to. 150 ''' 151 target_node = node 152 name = self.get_child_data(target_node,tag='name',strip=True) 153 path = self.get_child_data(target_node,tag='path',strip=True) 154 jam_target = self.get_child_data(target_node,tag='jam-target',strip=True) 155 #~ Map for jam targets to virtual targets. 156 self.target[jam_target] = { 157 'name' : name, 158 'path' : path 159 } 160 #~ Create the ancestry. 161 dep_node = self.get_child(self.get_child(target_node,tag='dependencies'),tag='dependency') 162 while dep_node: 163 child = self.get_data(dep_node,strip=True) 164 child_jam_target = '<p%s>%s' % (path,child.split('//',1)[1]) 165 self.parent[child_jam_target] = jam_target 166 dep_node = self.get_sibling(dep_node.nextSibling,tag='dependency') 167 return None 168 169 def x_build_action( self, node ): 170 ''' 171 Given a build action log, process into the corresponding test log and 172 specific test log sub-part. 173 ''' 174 action_node = node 175 name = self.get_child(action_node,tag='name') 176 if name: 177 name = self.get_data(name) 178 #~ Based on the action, we decide what sub-section the log 179 #~ should go into. 180 action_type = None 181 if re.match('[^%]+%[^.]+[.](compile)',name): 182 action_type = 'compile' 183 elif re.match('[^%]+%[^.]+[.](link|archive)',name): 184 action_type = 'link' 185 elif re.match('[^%]+%testing[.](capture-output)',name): 186 action_type = 'run' 187 elif re.match('[^%]+%testing[.](expect-failure|expect-success)',name): 188 action_type = 'result' 189 else: 190 # TODO: Enable to see what other actions can be included in the test results. 191 # action_type = None 192 action_type = 'other' 193 #~ print "+ [%s] %s %s :: %s" %(action_type,name,'','') 194 if action_type: 195 #~ Get the corresponding test. 196 (target,test) = self.get_test(action_node,type=action_type) 197 #~ Skip action that have no corresponding test as they are 198 #~ regular build actions and don't need to show up in the 199 #~ regression results. 200 if not test: 201 ##print "??? [%s] %s %s :: %s" %(action_type,name,target,test) 202 return None 203 ##print "+++ [%s] %s %s :: %s" %(action_type,name,target,test) 204 #~ Collect some basic info about the action. 205 action = { 206 'command' : self.get_action_command(action_node,action_type), 207 'output' : self.get_action_output(action_node,action_type), 208 'info' : self.get_action_info(action_node,action_type) 209 } 210 #~ For the test result status we find the appropriate node 211 #~ based on the type of test. Then adjust the result status 212 #~ accordingly. This makes the result status reflect the 213 #~ expectation as the result pages post processing does not 214 #~ account for this inversion. 215 action['type'] = action_type 216 if action_type == 'result': 217 if re.match(r'^compile',test['test-type']): 218 action['type'] = 'compile' 219 elif re.match(r'^link',test['test-type']): 220 action['type'] = 'link' 221 elif re.match(r'^run',test['test-type']): 222 action['type'] = 'run' 223 #~ The result sub-part we will add this result to. 224 if action_node.getAttribute('status') == '0': 225 action['result'] = 'succeed' 226 else: 227 action['result'] = 'fail' 228 # Add the action to the test. 229 test['actions'].append(action) 230 # Set the test result if this is the result action for the test. 231 if action_type == 'result': 232 test['result'] = action['result'] 233 return None 234 235 def x_build_timestamp( self, node ): 236 ''' 237 The time-stamp goes to the corresponding attribute in the result. 238 ''' 239 self.timestamps.append(self.get_data(node).strip()) 240 return None 241 242 def get_test( self, node, type = None ): 243 ''' 244 Find the test corresponding to an action. For testing targets these 245 are the ones pre-declared in the --dump-test option. For libraries 246 we create a dummy test as needed. 247 ''' 248 jam_target = self.get_child_data(node,tag='jam-target') 249 base = self.target[jam_target]['name'] 250 target = jam_target 251 while target in self.parent: 252 target = self.parent[target] 253 #~ print "--- TEST: %s ==> %s" %(jam_target,target) 254 #~ main-target-type is a precise indicator of what the build target is 255 #~ originally meant to be. 256 #main_type = self.get_child_data(self.get_child(node,tag='properties'), 257 # name='main-target-type',strip=True) 258 main_type = None 259 if main_type == 'LIB' and type: 260 lib = self.target[target]['name'] 261 if not lib in self.test: 262 self.test[lib] = { 263 'library' : re.search(r'libs/([^/]+)',lib).group(1), 264 'test-name' : os.path.basename(lib), 265 'test-type' : 'lib', 266 'test-program' : os.path.basename(lib), 267 'target' : lib 268 } 269 test = self.test[lib] 270 else: 271 target_name_ = self.target[target]['name'] 272 if self.target_to_test.has_key(target_name_): 273 test = self.test[self.target_to_test[target_name_]] 274 else: 275 test = None 276 return (base,test) 277 278 #~ The command executed for the action. For run actions we omit the command 279 #~ as it's just noise. 280 def get_action_command( self, action_node, action_type ): 281 if action_type != 'run': 282 return self.get_child_data(action_node,tag='command') 283 else: 284 return '' 285 286 #~ The command output. 287 def get_action_output( self, action_node, action_type ): 288 return self.get_child_data(action_node,tag='output',default='') 289 290 #~ Some basic info about the action. 291 def get_action_info( self, action_node, action_type ): 292 info = {} 293 #~ The jam action and target. 294 info['name'] = self.get_child_data(action_node,tag='name') 295 info['path'] = self.get_child_data(action_node,tag='path') 296 #~ The timing of the action. 297 info['time-start'] = action_node.getAttribute('start') 298 info['time-end'] = action_node.getAttribute('end') 299 info['time-user'] = action_node.getAttribute('user') 300 info['time-system'] = action_node.getAttribute('system') 301 #~ Testing properties. 302 test_info_prop = self.get_child_data(self.get_child(action_node,tag='properties'),name='test-info') 303 info['always_show_run_output'] = test_info_prop == 'always_show_run_output' 304 #~ And for compiles some context that may be hidden if using response files. 305 if action_type == 'compile': 306 info['define'] = [] 307 define = self.get_child(self.get_child(action_node,tag='properties'),name='define') 308 while define: 309 info['define'].append(self.get_data(define,strip=True)) 310 define = self.get_sibling(define.nextSibling,name='define') 311 return info 312 313class BuildConsoleSummaryReport(object): 314 315 HEADER = '\033[35m\033[1m' 316 INFO = '\033[34m' 317 OK = '\033[32m' 318 WARNING = '\033[33m' 319 FAIL = '\033[31m' 320 ENDC = '\033[0m' 321 322 def __init__(self, bop, opt): 323 self.bop = bop 324 325 def generate(self): 326 self.summary_info = { 327 'total' : 0, 328 'success' : 0, 329 'failed' : [], 330 } 331 self.header_print("======================================================================") 332 self.print_test_log() 333 self.print_summary() 334 self.header_print("======================================================================") 335 336 @property 337 def failed(self): 338 return len(self.summary_info['failed']) > 0 339 340 def print_test_log(self): 341 self.header_print("Tests run..") 342 self.header_print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~") 343 for k in sorted(self.bop.test.keys()): 344 test = self.bop.test[k] 345 if len(test['actions']) > 0: 346 self.summary_info['total'] += 1 347 ##print ">>>> {0}".format(test['test-name']) 348 if 'result' in test: 349 succeed = test['result'] == 'succeed' 350 else: 351 succeed = test['actions'][-1]['result'] == 'succeed' 352 if succeed: 353 self.summary_info['success'] += 1 354 else: 355 self.summary_info['failed'].append(test) 356 if succeed: 357 self.ok_print("[PASS] {0}",k) 358 else: 359 self.fail_print("[FAIL] {0}",k) 360 for action in test['actions']: 361 self.print_action(succeed, action) 362 363 def print_action(self, test_succeed, action): 364 ''' 365 Print the detailed info of failed or always print tests. 366 ''' 367 #self.info_print(">>> {0}",action.keys()) 368 if not test_succeed or action['info']['always_show_run_output']: 369 output = action['output'].strip() 370 if output != "": 371 p = self.fail_print if action['result'] == 'fail' else self.p_print 372 self.info_print("") 373 self.info_print("({0}) {1}",action['info']['name'],action['info']['path']) 374 p("") 375 p("{0}",action['command'].strip()) 376 p("") 377 for line in output.splitlines(): 378 p("{0}",line.encode('utf-8')) 379 380 def print_summary(self): 381 self.header_print("") 382 self.header_print("Testing summary..") 383 self.header_print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~") 384 self.p_print("Total: {0}",self.summary_info['total']) 385 self.p_print("Success: {0}",self.summary_info['success']) 386 if self.failed: 387 self.fail_print("Failed: {0}",len(self.summary_info['failed'])) 388 for test in self.summary_info['failed']: 389 self.fail_print(" {0}/{1}",test['library'],test['test-name']) 390 391 def p_print(self, format, *args, **kargs): 392 print format.format(*args,**kargs) 393 394 def info_print(self, format, *args, **kargs): 395 print self.INFO+format.format(*args,**kargs)+self.ENDC 396 397 def header_print(self, format, *args, **kargs): 398 print self.HEADER+format.format(*args,**kargs)+self.ENDC 399 400 def ok_print(self, format, *args, **kargs): 401 print self.OK+format.format(*args,**kargs)+self.ENDC 402 403 def warn_print(self, format, *args, **kargs): 404 print self.WARNING+format.format(*args,**kargs)+self.ENDC 405 406 def fail_print(self, format, *args, **kargs): 407 print self.FAIL+format.format(*args,**kargs)+self.ENDC 408 409class Main(object): 410 411 def __init__(self,args=None): 412 op = optparse.OptionParser( 413 usage="%prog [options] input+") 414 op.add_option( '--output', 415 help="type of output to generate" ) 416 ( opt, inputs ) = op.parse_args(args) 417 bop = BuildOutputProcessor(inputs) 418 output = None 419 if opt.output == 'console': 420 output = BuildConsoleSummaryReport(bop, opt) 421 if output: 422 output.generate() 423 self.failed = output.failed 424 425if __name__ == '__main__': 426 m = Main() 427 if m.failed: 428 exit(-1) 429