| # 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. |
| |
| """Touch firmware test report in html format.""" |
| |
| import os |
| import urllib |
| |
| import common_util |
| import firmware_log |
| import test_conf as conf |
| |
| from firmware_utils import get_fw_and_date |
| from string import Template |
| from validators import get_base_name_and_segment |
| |
| |
| 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 $test_version $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.criteria_string = ' criteria: %s' |
| self.validator_template = Template(''' |
| <tr> |
| <pre><span style="color:$color"><b>$name</b></span> |
| $details |
| $criteria |
| </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(' ' * 2 + detail.strip()) |
| return '<br>'.join(details_content) |
| |
| def _insert_vlog(self, vlog): |
| """Insert a single vlog.""" |
| base_name, _ = get_base_name_and_segment(vlog.name) |
| criteria_string = self.criteria_string % vlog.criteria |
| vlog_content = self.validator_template.safe_substitute( |
| name=vlog.name, |
| details=self._insert_details(vlog.details), |
| criteria=criteria_string, |
| color='blue', |
| score=vlog.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): |
| """Insert glog, image, and vlogs.""" |
| vlogs_content = self._insert_vlogs(glog.vlogs) |
| gesture = self.gesture_template.safe_substitute( |
| gesture_name=glog.name, |
| variation=glog.variation, |
| prompt=glog.prompt, |
| image=image, |
| filename=image_filename, |
| vlogs=vlogs_content) |
| self.gestures.append(gesture) |
| |
| def get_doc(self, test_version): |
| gestures = ''.join(self.gestures) |
| new_table = self.table.safe_substitute(gestures=gestures) |
| new_doc = self.doc.safe_substitute(test_version=test_version, |
| logs=new_table) |
| return new_doc |
| |
| |
| class ReportHtml: |
| """Firmware Report in html format.""" |
| |
| def __init__(self, filename, screen_size, touch_device_window_size, |
| score_colors, test_version): |
| self.html_filename = filename |
| self.screen_size = screen_size |
| self.image_width = self.screen_size[0] * 0.5 |
| touch_width, touch_height = touch_device_window_size |
| self.image_height = self.image_width / touch_width * touch_height |
| self.doc = TemplateHtml(self.image_width, self.image_height, |
| score_colors) |
| self._reset_content() |
| self.test_version = test_version |
| fw_and_date = get_fw_and_date(filename) |
| self.rlog = firmware_log.RoundLog(test_version, *fw_and_date) |
| |
| 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(self.test_version)) |
| # 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 byte stream file |
| log_file_root = os.path.splitext(self.html_filename)[0] |
| log_filename = os.extsep.join([log_file_root, 'log']) |
| self.rlog.dump(log_filename) |
| |
| def _reset_content(self): |
| self.glog = firmware_log.GestureLog() |
| self.encoded_image='' |
| self.image_filename='' |
| |
| def _get_content(self): |
| return [self.glog, self.encoded_image, self.image_filename] |
| |
| def _encode_base64(self, filename): |
| """Encode a file in base 64 format.""" |
| if (filename is None) or (not os.path.isfile(filename)): |
| return None |
| encoded = urllib.quote(open(filename, "rb").read().encode("base64")) |
| return encoded |
| |
| def flush(self): |
| """Flush the current gesture including gesture log, image and |
| validator logs. |
| """ |
| content = self._get_content() |
| # It is ok to flush the gesture log even when there are no mtplot images |
| if self.glog: |
| # Write the content to the html file. |
| self.doc.insert_gesture(*content) |
| # Write the logs to the round log. |
| self.rlog.insert_glog(self.glog) |
| 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, glog): |
| """Update the gesture log.""" |
| self.glog = glog |
| |
| def insert_validator_logs(self, vlogs): |
| """Update the validator logs.""" |
| self.glog.vlogs = vlogs |
