def main():
  """CLI frontend to validate arguments."""
  run_isolated.disable_buffering()
  parser = run_test_cases.OptionParserWithTestShardingAndFiltering(
      usage='%prog <options> [gtest]')

  # Override default seed value to default to 0.
  parser.set_defaults(seed=0)

  options, args = parser.parse_args()
  if not args:
    parser.error('Please provide the executable to run')

  cmd = run_isolated.fix_python_path(args)
  try:
    tests = run_test_cases.chromium_list_test_cases(
        cmd,
        os.getcwd(),
        index=options.index,
        shards=options.shards,
        seed=options.seed,
        disabled=options.disabled,
        fails=options.fails,
        flaky=options.flaky,
        pre=False,
        manual=options.manual)
    for test in tests:
      print test
  except run_test_cases.Failure, e:
    print e.args[0]
    return e.args[1]
Ejemplo n.º 2
0
def main():
  parser = run_test_cases.OptionParserTestCases(
      usage='%prog <options> -s <something.isolated>')
  parser.add_option(
      '-s', '--isolated',
      help='The isolated file')
  options, args = parser.parse_args()

  if args:
    parser.error('Unsupported arg: %s' % args)
  if not options.isolated:
    parser.error('--isolated is required')
  if not options.isolated.endswith('.isolated'):
    parser.error('--isolated argument must end with .isolated')

  # Retrieve the command from the .isolated file.
  with open(options.isolated) as f:
    data = run_isolated.load_isolated(f.read())
  if 'includes' in data:
    parser.error('includes key is not supported yet')

  command = data.get('command')
  if not command:
    parser.error('A command must be defined')
  test_cases = parser.process_gtest_options(
      run_isolated.fix_python_path(command),
      data.get('relative_cwd', os.getcwd()),
      options)
  if not test_cases:
    print >> sys.stderr, 'No test case to run'
    return 1

  return not fix_all(options.isolated, test_cases)
def main():
  """CLI frontend to validate arguments."""
  run_isolated.disable_buffering()
  parser = run_test_cases.OptionParserTestCases(
      usage='%prog <options> [gtest]')
  parser.format_description = lambda *_: parser.description
  parser.add_option(
      '-o', '--out',
      help='output file, defaults to <executable>.test_cases')
  parser.add_option(
      '-r', '--root-dir',
      help='Root directory under which file access should be noted')
  parser.add_option(
      '--trace-blacklist', action='append', default=[],
      help='List of regexp to use as blacklist filter')
  # TODO(maruel): Add support for options.timeout.
  parser.remove_option('--timeout')
  options, args = parser.parse_args()

  if not args:
    parser.error(
        'Please provide the executable line to run, if you need fancy things '
        'like xvfb, start this script from *inside* xvfb, it\'ll be much faster'
        '.')

  cmd = run_isolated.fix_python_path(args)
  cmd[0] = os.path.abspath(cmd[0])
  if not os.path.isfile(cmd[0]):
    parser.error('Tracing failed for: %s\nIt doesn\'t exit' % ' '.join(cmd))

  if not options.out:
    options.out = '%s.test_cases' % cmd[-1]
  options.out = os.path.abspath(options.out)
  if options.root_dir:
    options.root_dir = os.path.abspath(options.root_dir)
  logname = options.out + '.log'

  test_cases = parser.process_gtest_options(cmd, os.getcwd(), options)

  # Then run them.
  print('Tracing...')
  results = trace_test_cases(
      cmd,
      os.getcwd(),
      test_cases,
      options.jobs,
      logname)
  print('Reading trace logs...')
  blacklist = trace_inputs.gen_blacklist(options.trace_blacklist)
  write_details(logname, options.out, options.root_dir, blacklist, results)
  return 0
def safely_load_isolated(parser, options):
  """Loads a .isolated.state to extract the executable information.

  Returns the CompleteState instance, the command and the list of test cases.
  """
  config = isolate.CompleteState.load_files(options.isolated)
  logging.debug(
      'root_dir: %s  relative_cwd: %s  isolated: %s',
      config.root_dir, config.saved_state.relative_cwd, options.isolated)
  reldir = os.path.join(config.root_dir, config.saved_state.relative_cwd)
  command = config.saved_state.command
  test_cases = []
  if command:
    command = run_isolated.fix_python_path(command)
    test_xvfb(command, reldir)
    test_cases = parser.process_gtest_options(command, reldir, options)
  return config, command, test_cases
def test_xvfb(command, rel_dir):
  """Calls back ourself if not running inside Xvfb and it's on the command line
  to run.

  Otherwise the X session will die while trying to start too many Xvfb
  instances.
  """
  if os.environ.get('_CHROMIUM_INSIDE_XVFB') == '1':
    return
  for index, item in enumerate(command):
    if item.endswith('xvfb.py'):
      # Note this has inside knowledge about src/testing/xvfb.py.
      print('Restarting itself under Xvfb')
      prefix = command[index:index+2]
      prefix[0] = os.path.normpath(os.path.join(rel_dir, prefix[0]))
      prefix[1] = os.path.normpath(os.path.join(rel_dir, prefix[1]))
      cmd = run_isolated.fix_python_path(prefix + sys.argv)
      sys.exit(subprocess.call(cmd))
def main():
  run_isolated.disable_buffering()
  parser = optparse.OptionParser(usage='%prog <options> [gtest]')
  parser.disable_interspersed_args()
  parser.add_option(
      '-I', '--index',
      type='int',
      default=os.environ.get('GTEST_SHARD_INDEX'),
      help='Shard index to run')
  parser.add_option(
      '-S', '--shards',
      type='int',
      default=os.environ.get('GTEST_TOTAL_SHARDS'),
      help='Total number of shards to calculate from the --index to run')
  options, args = parser.parse_args()
  env = os.environ.copy()
  env['GTEST_TOTAL_SHARDS'] = str(options.shards)
  env['GTEST_SHARD_INDEX'] = str(options.index)
  return subprocess.call(run_isolated.fix_python_path(args), env=env)
Ejemplo n.º 7
0
def main(argv):
  """CLI frontend to validate arguments."""
  parser = OptionParserTestCases(
      usage='%prog <options> [gtest]',
      verbose=int(os.environ.get('ISOLATE_DEBUG', 0)))
  parser.add_option(
      '--run-all',
      action='store_true',
      help='Do not fail early when a large number of test cases fail')
  parser.add_option(
      '--max-failures', type='int',
      help='Limit the number of failures before aborting')
  parser.add_option(
      '--retries', type='int', default=2,
      help='Number of times each test case should be retried in case of '
           'failure.')
  parser.add_option(
      '--no-dump',
      action='store_true',
      help='do not generate a .run_test_cases file')
  parser.add_option(
      '--no-cr',
      action='store_true',
      help='Use LF instead of CR for status progress')
  parser.add_option(
      '--result',
      help='Override the default name of the generated .run_test_cases file')

  group = optparse.OptionGroup(parser, 'google-test compability flags')
  group.add_option(
      '--gtest_list_tests',
      action='store_true',
      help='List all the test cases unformatted. Keeps compatibility with the '
           'executable itself.')
  group.add_option(
      '--gtest_output',
      default=os.environ.get('GTEST_OUTPUT', ''),
      help='XML output to generate')
  parser.add_option_group(group)

  options, args = parser.parse_args(argv)

  if not args:
    parser.error(
        'Please provide the executable line to run, if you need fancy things '
        'like xvfb, start this script from *inside* xvfb, it\'ll be much faster'
        '.')

  if options.run_all and options.max_failures is not None:
    parser.error('Use only one of --run-all or --max-failures')

  cmd = fix_python_path(args)

  if options.gtest_list_tests:
    # Special case, return the output of the target unmodified.
    return subprocess.call(cmd + ['--gtest_list_tests'])

  cwd = os.getcwd()
  test_cases = parser.process_gtest_options(cmd, cwd, options)
  if not test_cases:
    # If test_cases is None then there was a problem generating the tests to
    # run, so this should be considered a failure.
    return int(test_cases is None)

  if options.no_dump:
    result_file = None
  else:
    result_file = options.result or '%s.run_test_cases' % args[-1]

  return run_test_cases(
      cmd,
      cwd,
      test_cases,
      options.jobs,
      options.timeout,
      options.retries,
      options.run_all,
      options.max_failures,
      options.no_cr,
      options.gtest_output,
      result_file,
      options.verbose)