| # Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Touchpad firmware test report in html format.""" |
| |
| import json |
| import os |
| import re |
| import sys |
| import time |
| import urllib |
| |
| import common_util |
| import firmware_log |
| import test_conf as conf |
| |
| from firmware_constants import VLOG |
| from string import Template |
| |
| |
| class TemplateHtml: |
| """An html Template.""" |
| |
| def __init__(self, image_width, image_height, score_colors): |
| self.score_colors = score_colors |
| |
| # Define the template of the doc |
| self.doc = Template('$head $summary $logs $tail') |
| self.table = Template('<table border="3" width="100%"> $gestures ' |
| '</table>') |
| self.gestures = [] |
| |
| # Define a template to show a gesture information including |
| # the gesture name, variation, prompt, image, and test results. |
| self.gesture_template = Template(''' |
| <tr> |
| <td><table> |
| <tr> |
| <h3> $gesture_name.$variation </h3> |
| <h5> $prompt </h5> |
| </tr> |
| <tr> |
| <img src="data:image/png;base64,\n$image" |
| alt="$filename" width="%d" height="%d" /> |
| </tr> |
| </table></td> |
| <td><table> |
| $vlogs |
| </table></td> |
| </tr> |
| ''' % (image_width, image_height)) |
| |
| self.validator_template = Template(''' |
| <tr> |
| <pre><span style="color:$color"><b>$name</b></span> |
| $details |
| criteria: $criteria |
| <span style="color:$color"><b>score: $score</b></span></pre> |
| </tr> |
| ''') |
| |
| self.detail_template = Template('<tr><h5> $detail </h5></tr>') |
| self._fill_doc() |
| |
| def _html_head(self): |
| """Fill the head of an html document.""" |
| head = '\n'.join(['<!DOCTYPE html>', '<html>', '<body>']) |
| return head |
| |
| def _html_tail(self): |
| """Fill the tail of an html document.""" |
| tail = '\n'.join(['</body>', '</html>']) |
| return tail |
| |
| def _fill_doc(self): |
| """Fill in fields into the doc.""" |
| self.doc = Template(self.doc.safe_substitute(head=self._html_head(), |
| tail=self._html_tail())) |
| |
| def get_score_color(self, score): |
| """Present the score in different colors.""" |
| for s, c in self.score_colors: |
| if score >= s: |
| return c |
| |
| def _insert_details(self, details): |
| details_content = [] |
| for detail in details: |
| details_content.append(' ' * 4 + detail.strip()) |
| return '<br>'.join(details_content) |
| |
| def _insert_vlog(self, vlog): |
| """Insert a single vlog.""" |
| score=vlog.get_score() |
| vlog_content = self.validator_template.safe_substitute( |
| name=vlog.get_name(), |
| details=self._insert_details(vlog.get_details()), |
| criteria=vlog.get_criteria(), |
| color=self.get_score_color(score), |
| score=score) |
| return vlog_content |
| |
| def _insert_vlogs(self, vlogs): |
| """Insert multiple vlogs.""" |
| vlogs_content = [] |
| for vlog in vlogs: |
| vlogs_content.append(self._insert_vlog(vlog)) |
| return '<hr>'.join(vlogs_content) |
| |
| def insert_gesture(self, glog, image, image_filename, vlogs): |
| """Insert glog, image, and vlogs.""" |
| vlogs_content = self._insert_vlogs(vlogs) |
| gesture = self.gesture_template.safe_substitute( |
| gesture_name=glog.get_name(), |
| variation=glog.get_variation(), |
| prompt=glog.get_prompt(), |
| image=image, |
| filename=image_filename, |
| vlogs=vlogs_content) |
| self.gestures.append(gesture) |
| |
| def get_doc(self): |
| gestures = ''.join(self.gestures) |
| new_table = self.table.safe_substitute(gestures=gestures) |
| new_doc = self.doc.safe_substitute(logs=new_table) |
| return new_doc |
| |
| |
| class ReportHtml: |
| """Firmware Report in html format.""" |
| |
| def __init__(self, filename, screen_size, touchpad_window_size, |
| score_colors): |
| self.html_filename = filename |
| self.screen_size = screen_size |
| self.image_width = self.screen_size[0] * 0.5 |
| touchpad_width, touchpad_height = touchpad_window_size |
| self.image_height = self.image_width / touchpad_width * touchpad_height |
| self.doc = TemplateHtml(self.image_width, self.image_height, |
| score_colors) |
| self._reset_content() |
| self.log_dict = {} |
| self.log_dict[VLOG.DICT] = {} |
| self.log_dict[VLOG.GV_LIST] = [] |
| |
| def __del__(self): |
| self.stop() |
| |
| def stop(self): |
| """Close the file.""" |
| with open(self.html_filename, 'w') as report_file: |
| report_file.write(self.doc.get_doc()) |
| # Make a copy to /tmp so that it could be viewed in Chrome. |
| tmp_copy = os.path.join(conf.docroot, |
| os.path.basename(self.html_filename)) |
| copy_cmd = 'cp %s %s' % (self.html_filename, tmp_copy) |
| common_util.simple_system(copy_cmd) |
| |
| # Dump the logs to a json file |
| log_file_root = os.path.splitext(self.html_filename)[0] |
| log_file_name = os.extsep.join([log_file_root, 'log']) |
| with open(log_file_name, 'w') as log_file: |
| json.dump(self.log_dict, log_file) |
| |
| def _reset_content(self): |
| self.glog = firmware_log.GestureLog() |
| self.encoded_image='' |
| self.image_filename='' |
| self.vlogs = [] |
| |
| def _get_content(self): |
| return [self.glog, self.encoded_image, self.image_filename, self.vlogs] |
| |
| def _encode_base64(self, filename): |
| """Encode a file in base 64 format.""" |
| if not os.path.isfile(filename): |
| return None |
| encoded = urllib.quote(open(filename, "rb").read().encode("base64")) |
| return encoded |
| |
| def reset_logs(self): |
| "Reset the details of vlogs." |
| for vlog in self.vlogs: |
| vlog.reset() |
| |
| def _insert_log_dict(self, glog, vlogs): |
| """Insert the glog and vlogs key value pair into the log dictionary.""" |
| vlogs_scores = [] |
| for vlog in vlogs: |
| vlog_score = {vlog.get_name(): vlog.get_score()} |
| vlogs_scores.append(vlog_score) |
| glog_key = str([glog.get_name(), glog.get_variation()]) |
| self.log_dict[VLOG.DICT][glog_key] = vlogs_scores |
| self.log_dict[VLOG.GV_LIST].append(glog_key) |
| |
| def flush(self): |
| """Flush the current gesture including gesture log, image and |
| validator logs. |
| """ |
| content = self._get_content() |
| if all(content): |
| self.doc.insert_gesture(*content) |
| self._insert_log_dict(self.glog, self.vlogs) |
| self.reset_logs() |
| self._reset_content() |
| |
| def insert_image(self, filename): |
| """Insert an image into the document.""" |
| self.encoded_image = self._encode_base64(filename) |
| self.image_filename = filename |
| |
| def insert_result(self, text): |
| """Insert the text into the document.""" |
| self.result += text |
| |
| def insert_gesture_log(self, log): |
| """Update the gesture log.""" |
| self.glog.update(log) |
| |
| def insert_validator_logs(self, logs): |
| """Update the validator logs.""" |
| self.vlogs = logs |
