#!/usr/bin/env python

#

# run-tests.py - Run a set of tests on Mercurial

#

# Copyright 2006 Matt Mackall <mpm@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

# Modifying this script is tricky because it has many modes:

#   - serial (default) vs parallel (-jN, N > 1)

#   - no coverage (default) vs coverage (-c, -C, -s)

#   - temp install (default) vs specific hg script (--with-hg, --local)

#   - tests are a mix of shell scripts and Python scripts

#

# If you change this script, it is recommended that you ensure you

# haven't broken it by running it in various modes with a representative

# sample of test scripts.  For example:

#

#  1) serial, no coverage, temp install:

#      ./run-tests.py test-s*

#  2) serial, no coverage, local hg:

#      ./run-tests.py --local test-s*

#  3) serial, coverage, temp install:

#      ./run-tests.py -c test-s*

#  4) serial, coverage, local hg:

#      ./run-tests.py -c --local test-s*      # unsupported

#  5) parallel, no coverage, temp install:

#      ./run-tests.py -j2 test-s*

#  6) parallel, no coverage, local hg:

#      ./run-tests.py -j2 --local test-s*

#  7) parallel, coverage, temp install:

#      ./run-tests.py -j2 -c test-s*          # currently broken

#  8) parallel, coverage, local install:

#      ./run-tests.py -j2 -c --local test-s*  # unsupported (and broken)

#  9) parallel, custom tmp dir:

#      ./run-tests.py -j2 --tmpdir /tmp/myhgtests

#

# (You could use any subset of the tests: test-s* happens to match

# enough that it's worth doing parallel runs, few enough that it

# completes fairly quickly, includes both shell and Python scripts, and

# includes some scripts that run daemon processes.)

from distutils import version

import difflib

import errno

import optparse

import os

import shutil

import subprocess

import signal

import sys

import tempfile

import time

import random

import re

import threading

import killdaemons as killmod

import Queue as queue

processlock = threading.Lock()

# subprocess._cleanup can race with any Popen.wait or Popen.poll on py24

# http://bugs.python.org/issue1731717 for details. We shouldn't be producing

# zombies but it's pretty harmless even if we do.

if sys.version_info < (2, 5):

    subprocess._cleanup = lambda: None

closefds = os.name == 'posix'

def Popen4(cmd, wd, timeout, env=None):

    processlock.acquire()

    p = subprocess.Popen(cmd, shell=True, bufsize=-1, cwd=wd, env=env,

                         close_fds=closefds,

                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,

                         stderr=subprocess.STDOUT)

    processlock.release()

    p.fromchild = p.stdout

    p.tochild = p.stdin

    p.childerr = p.stderr

    p.timeout = False

    if timeout:

        def t():

            start = time.time()

            while time.time() - start < timeout and p.returncode is None:

                time.sleep(.1)

            p.timeout = True

            if p.returncode is None:

                terminate(p)

        threading.Thread(target=t).start()

    return p

# reserved exit code to skip test (used by hghave)

SKIPPED_STATUS = 80

SKIPPED_PREFIX = 'skipped: '

FAILED_PREFIX  = 'hghave check failed: '

PYTHON = sys.executable.replace('\\', '/')

IMPL_PATH = 'PYTHONPATH'

if 'java' in sys.platform:

    IMPL_PATH = 'JYTHONPATH'

TESTDIR = HGTMP = INST = BINDIR = TMPBINDIR = PYTHONDIR = None

requiredtools = [os.path.basename(sys.executable), "diff", "grep", "unzip",

                 "gunzip", "bunzip2", "sed"]

defaults = {

    'jobs': ('HGTEST_JOBS', 1),

    'timeout': ('HGTEST_TIMEOUT', 180),

    'port': ('HGTEST_PORT', 20059),

    'shell': ('HGTEST_SHELL', 'sh'),

}

def parselistfiles(files, listtype, warn=True):

    entries = dict()

    for filename in files:

        try:

            path = os.path.expanduser(os.path.expandvars(filename))

            f = open(path, "r")

        except IOError, err:

            if err.errno != errno.ENOENT:

                raise

            if warn:

                print "warning: no such %s file: %s" % (listtype, filename)

            continue

        for line in f.readlines():

            line = line.split('#', 1)[0].strip()

            if line:

                entries[line] = filename

        f.close()

    return entries

def getparser():

    parser = optparse.OptionParser("%prog [options] [tests]")

    # keep these sorted

    parser.add_option("--blacklist", action="append",

        help="skip tests listed in the specified blacklist file")

    parser.add_option("--whitelist", action="append",

        help="always run tests listed in the specified whitelist file")

    parser.add_option("--changed", type="string",

        help="run tests that are changed in parent rev or working directory")

    parser.add_option("-C", "--annotate", action="store_true",

        help="output files annotated with coverage")

    parser.add_option("-c", "--cover", action="store_true",

        help="print a test coverage report")

    parser.add_option("-d", "--debug", action="store_true",

        help="debug mode: write output of test scripts to console"

             " rather than capturing and diffing it (disables timeout)")

    parser.add_option("-f", "--first", action="store_true",

        help="exit on the first test failure")

    parser.add_option("-H", "--htmlcov", action="store_true",

        help="create an HTML report of the coverage of the files")

    parser.add_option("-i", "--interactive", action="store_true",

        help="prompt to accept changed output")

    parser.add_option("-j", "--jobs", type="int",

        help="number of jobs to run in parallel"

             " (default: $%s or %d)" % defaults['jobs'])

    parser.add_option("--keep-tmpdir", action="store_true",

        help="keep temporary directory after running tests")

    parser.add_option("-k", "--keywords",

        help="run tests matching keywords")

    parser.add_option("-l", "--local", action="store_true",

        help="shortcut for --with-hg=<testdir>/../hg")

    parser.add_option("--loop", action="store_true",

        help="loop tests repeatedly")

    parser.add_option("-n", "--nodiff", action="store_true",

        help="skip showing test changes")

    parser.add_option("-p", "--port", type="int",

        help="port on which servers should listen"

             " (default: $%s or %d)" % defaults['port'])

    parser.add_option("--compiler", type="string",

        help="compiler to build with")

    parser.add_option("--pure", action="store_true",

        help="use pure Python code instead of C extensions")

    parser.add_option("-R", "--restart", action="store_true",

        help="restart at last error")

    parser.add_option("-r", "--retest", action="store_true",

        help="retest failed tests")

    parser.add_option("-S", "--noskips", action="store_true",

        help="don't report skip tests verbosely")

    parser.add_option("--shell", type="string",

        help="shell to use (default: $%s or %s)" % defaults['shell'])

    parser.add_option("-t", "--timeout", type="int",

        help="kill errant tests after TIMEOUT seconds"

             " (default: $%s or %d)" % defaults['timeout'])

    parser.add_option("--time", action="store_true",

        help="time how long each test takes")

    parser.add_option("--tmpdir", type="string",

        help="run tests in the given temporary directory"

             " (implies --keep-tmpdir)")

    parser.add_option("-v", "--verbose", action="store_true",

        help="output verbose messages")

    parser.add_option("--view", type="string",

        help="external diff viewer")

    parser.add_option("--with-hg", type="string",

        metavar="HG",

        help="test using specified hg script rather than a "

             "temporary installation")

    parser.add_option("-3", "--py3k-warnings", action="store_true",

        help="enable Py3k warnings on Python 2.6+")

    parser.add_option('--extra-config-opt', action="append",

                      help='set the given config opt in the test hgrc')

    parser.add_option('--random', action="store_true",

                      help='run tests in random order')

    for option, (envvar, default) in defaults.items():

        defaults[option] = type(default)(os.environ.get(envvar, default))

    parser.set_defaults(**defaults)

    return parser

def parseargs(args, parser):

    (options, args) = parser.parse_args(args)

    # jython is always pure

    if 'java' in sys.platform or '__pypy__' in sys.modules:

        options.pure = True

    if options.with_hg:

        options.with_hg = os.path.expanduser(options.with_hg)

        if not (os.path.isfile(options.with_hg) and

                os.access(options.with_hg, os.X_OK)):

            parser.error('--with-hg must specify an executable hg script')

        if not os.path.basename(options.with_hg) == 'hg':

            sys.stderr.write('warning: --with-hg should specify an hg script\n')

    if options.local:

        testdir = os.path.dirname(os.path.realpath(sys.argv[0]))

        hgbin = os.path.join(os.path.dirname(testdir), 'hg')

        if os.name != 'nt' and not os.access(hgbin, os.X_OK):

            parser.error('--local specified, but %r not found or not executable'

                         % hgbin)

        options.with_hg = hgbin

    options.anycoverage = options.cover or options.annotate or options.htmlcov

    if options.anycoverage:

        try:

            import coverage

            covver = version.StrictVersion(coverage.__version__).version

            if covver < (3, 3):

                parser.error('coverage options require coverage 3.3 or later')

        except ImportError:

            parser.error('coverage options now require the coverage package')

    if options.anycoverage and options.local:

        # this needs some path mangling somewhere, I guess

        parser.error("sorry, coverage options do not work when --local "

                     "is specified")

    global verbose

    if options.verbose:

        verbose = ''

    if options.tmpdir:

        options.tmpdir = os.path.expanduser(options.tmpdir)

    if options.jobs < 1:

        parser.error('--jobs must be positive')

    if options.interactive and options.debug:

        parser.error("-i/--interactive and -d/--debug are incompatible")

    if options.debug:

        if options.timeout != defaults['timeout']:

            sys.stderr.write(

                'warning: --timeout option ignored with --debug\n')

        options.timeout = 0

    if options.py3k_warnings:

        if sys.version_info[:2] < (2, 6) or sys.version_info[:2] >= (3, 0):

            parser.error('--py3k-warnings can only be used on Python 2.6+')

    if options.blacklist:

        options.blacklist = parselistfiles(options.blacklist, 'blacklist')

    if options.whitelist:

        options.whitelisted = parselistfiles(options.whitelist, 'whitelist')

    else:

        options.whitelisted = {}

    return (options, args)

def rename(src, dst):

    """Like os.rename(), trade atomicity and opened files friendliness

    for existing destination support.

    """

    shutil.copy(src, dst)

    os.remove(src)

def parsehghaveoutput(lines):

    '''Parse hghave log lines.

    Return tuple of lists (missing, failed):

      * the missing/unknown features

      * the features for which existence check failed'''

    missing = []

    failed = []

    for line in lines:

        if line.startswith(SKIPPED_PREFIX):

            line = line.splitlines()[0]

            missing.append(line[len(SKIPPED_PREFIX):])

        elif line.startswith(FAILED_PREFIX):

            line = line.splitlines()[0]

            failed.append(line[len(FAILED_PREFIX):])

    return missing, failed

def showdiff(expected, output, ref, err):

    print

    servefail = False

    for line in difflib.unified_diff(expected, output, ref, err):

        sys.stdout.write(line)

        if not servefail and line.startswith(

                             '+  abort: child process failed to start'):

            servefail = True

    return {'servefail': servefail}

verbose = False

def vlog(*msg):

    if verbose is not False:

        iolock.acquire()

        if verbose:

            print verbose,

        for m in msg:

            print m,

        print

        sys.stdout.flush()

        iolock.release()

def log(*msg):

    iolock.acquire()

    if verbose:

        print verbose,

    for m in msg:

        print m,

    print

    sys.stdout.flush()

    iolock.release()

def findprogram(program):

    """Search PATH for a executable program"""

    for p in os.environ.get('PATH', os.defpath).split(os.pathsep):

        name = os.path.join(p, program)

        if os.name == 'nt' or os.access(name, os.X_OK):

            return name

    return None

def createhgrc(path, options):

    # create a fresh hgrc

    hgrc = open(path, 'w')

    hgrc.write('[ui]\n')

    hgrc.write('slash = True\n')

    hgrc.write('interactive = False\n')

    hgrc.write('[defaults]\n')

    hgrc.write('backout = -d "0 0"\n')

    hgrc.write('commit = -d "0 0"\n')

    hgrc.write('shelve = --date "0 0"\n')

    hgrc.write('tag = -d "0 0"\n')

    if options.extra_config_opt:

        for opt in options.extra_config_opt:

            section, key = opt.split('.', 1)

            assert '=' in key, ('extra config opt %s must '

                                'have an = for assignment' % opt)

            hgrc.write('[%s]\n%s\n' % (section, key))

    hgrc.close()

def checktools():

    # Before we go any further, check for pre-requisite tools

    # stuff from coreutils (cat, rm, etc) are not tested