framework/src/main.py

# 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.
#
# This module is the main module for the console interface. It takes care
# of parsing the command line arguments and formating the output
from os import path
import json
import math
import os
import pprint
import sys

from table import Table
from test_case import TestCase
from test_factory import TestFactory
from test_runner import TestRunner
from test_verifier import TestVerifier

_help_text = """\
Available Commands:
-------------------
$ touchtests run [all|testname]
Executes tests. Either all of them and presents a resulting overall score.
Or just a single named test.

$ touchtests debug [testname]
Same as run, but additionally displays the gestures library log.

$ touchtests log [testname]
Executes a test and prints the activity_log to stdout. Useful to view the
results in tp_view.

$ touchtests add [platform] [activity_log] [cmt_log]
Adds a new test case. Each test belongs to a platform "lumpy", "cr48", etc.
activity_log and cmt_log should point to the file names of log files collected
from the device.
You can trim activity_log in tp_view, touchtests will automatically trim the
cmt_log accordingly.
The test will be named after the filename of the activity_log and a dummy
validation script is automatically generated.

General Info:
-------------
testname arguments:
Tests are always names as [platform]/[name of test case]. You can find the tests
available in the tests folder.
For example: lumpy/scroll_test

Tests Folder:
The tests folder contains a folder for each platform and all the test cases.
Each test case is made up of 3 files:
[testcase].py which contains the validation script
[testcase].log which contains the input_event log
[testcase].props which contains user_defined properties passed to gestures lib.

Platform folders:
To add a new platform you need to add a new folder to the Tests folder, and
generate a platform.dat file. This can be done using the evemu-describe tool
on the target platform:

$ gmerge utouch-evemu
$ evemu-describe /path/to/device > platform.dat
"""


def HelpExit():
  """
  Print help text and exit
  """
  print _help_text
  exit()

def Verify(device, glob):
  verifier = TestVerifier(os.environ["TESTS_DIR"], os.environ["REPLAY_TOOL"],
                          device)
  runner = TestRunner(os.environ["TESTS_DIR"], os.environ["REPLAY_TOOL"])
  cases = runner.DiscoverTestCases(glob)

  for case in cases:
    print "###", case.name
    report = verifier.Verify(case)
    print report


def Log(glob, debug=False):
  """
  Print only the activity log. The user can pipe the output of this command
  to be used in other tools like tpview.
  """
  runner = TestRunner(os.environ["TESTS_DIR"], os.environ["REPLAY_TOOL"])
  cases = runner.DiscoverTestCases(glob)

  # check number of test cases
  if len(cases) > 1:
    print "Multiple test cases match '" + str(glob) + "':"
    for case in cases:
      print " -", case.name
    return

  if len(cases) < 1:
    print "Cannot find test " + glob
    return

  # run test and print results
  results = runner.RunTest(cases[0])
  if results["error"]:
    print results["error"]
    return

  print results["logs"]["activity"]


def Run(glob, out_file=None, ref_file=None):
  print "Running tests..."
  runner = TestRunner(os.environ["TESTS_DIR"], os.environ["REPLAY_TOOL"])
  results = runner.RunAll(glob)

  # print reports
  for key, value in results.items():
    print "### Validation report for", key
    print value["logs"]["validation"]
    print value["error"]

  # load reference
  ref = {}
  if ref_file:
    ref = json.load(open(ref_file))

  # format result table
  table = Table()
  table.title = "Test Results"
  table.header("Test", "reference score", "new score", "delta")

  for key, value in results.items():
    def ResultStr(value):
      # format result to string
      if value["result"] == "success":
        return "%s (%.4f)" % (value["result"], value["score"])
      else:
        return value["result"]

    # format reference and delta column
    ref_score = ""
    delta_str = ""
    regression = False
    if key in ref:
      ref_score = ResultStr(ref[key])
      delta = value["score"] - ref[key]["score"]
      if math.fabs(delta) < 1e-10:
        # don't color, but line up with other values
        delta_str = "      %.4f    " % delta
      elif delta < 0:
        regression = True
        # color red
        delta_str = "\x1b[91m%+.4f\x1b[0m" % delta
      else:
        # color green
        delta_str = "\x1b[92m%+.4f\x1b[0m" % delta
    table.row(key, ref_score, ResultStr(value), delta_str)

  print table

  if out_file:
    json.dump(results, open(out_file, "w"), indent=2)
    print "results stored in:", out_file

  if regression:
    print "\x1b[91mThere are regressions present in this test run!\x1b[0m"
    exit(-1)

def Add(platform, activity_log, event_log):
  """
  Adds a new test case.
  """
  # determine test name from activity_log name
  testname = path.splitext(path.basename(activity_log))[0]
  testname = path.join(platform, testname)
  factory = TestFactory(os.environ["TESTS_DIR"], os.environ["REPLAY_TOOL"])
  case = factory.CreateTest(testname, activity_log, event_log)

  print "Test \"" + case.name + "\" created"

def Main():
  """
  Main entry point for the console interface
  """

  # setup paths from environment variables
  if "TESTS_DIR" not in os.environ:
    print "Require TESTS_DIR environment variable"
    exit(-1)

  if "REPLAY_TOOL" not in os.environ:
    print "Require REPLAY_TOOL environment variable"
    exit(-1)

  TestCase.tests_path = os.environ["TESTS_DIR"]
  TestCase.replay_tool = os.environ["REPLAY_TOOL"]

  # parse arguments and call command methods
  if len(sys.argv) < 2:
    HelpExit()

  # call command method according to command line arguments
  # todo: use an option parser library
  cmd = sys.argv[1]

  if cmd == "run":
    if len(sys.argv) == 3:
      test_name = sys.argv[2]
      Run(test_name)
    elif len(sys.argv) == 5 and sys.argv[2] == "--out":
      test_name = sys.argv[4]
      out = sys.argv[3]
      Run(test_name, out)
    elif len(sys.argv) == 5 and sys.argv[2] == "--ref":
      test_name = sys.argv[4]
      ref_file = sys.argv[3]
      Run(test_name, None, ref_file)
    else:
      HelpExit()

  elif cmd == "log":
    if len(sys.argv) < 3:
      HelpExit()
    test_name = sys.argv[2]
    Log(test_name)

  elif cmd == "verify":
    if len(sys.argv) < 4:
      HelpExit()
    device_name = sys.argv[2]
    test_name = sys.argv[3]
    Verify(device_name, test_name)

  elif cmd == "add":
    if len(sys.argv) < 5:
      HelpExit()
    platform = sys.argv[2]
    activity_log = sys.argv[3]
    event_log = sys.argv[4]
    Add(platform, activity_log, event_log)

  else:
    HelpExit()

if __name__ == "__main__":
  Main()