#!/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 re

import threading

processlock = threading.Lock()

closefds = os.name == 'posix'

def Popen4(cmd, wd, timeout):

    processlock.acquire()

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

                         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'

requiredtools = ["python", "diff", "grep", "unzip", "gunzip", "bunzip2", "sed"]

defaults = {

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

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

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

    'shell': ('HGTEST_SHELL', '/bin/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 parseargs():

    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("-C", "--annotate", action="store_true",

        help="output files annotated with coverage")

    parser.add_option("--child", type="int",

        help="run as child process, summary to given fd")

    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 diff'ing it (disables timeout)")

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

        help="exit on the first test failure")

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

        help="enable inotify extension when running tests")

    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("-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("--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("--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')

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

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

    parser.set_defaults(**defaults)

    (options, args) = parser.parse_args()

    # jython is always pure

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

        options.pure = True

    if 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 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

    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 vlog

    if options.verbose:

        if options.jobs > 1 or options.child is not None:

            pid = "[%d]" % os.getpid()

        else:

            pid = None

        def vlog(*msg):

            iolock.acquire()

            if pid:

                print pid,

            for m in msg:

                print m,

            print

            sys.stdout.flush()

            iolock.release()

    else:

        vlog = lambda *msg: None

    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.jobs > 1:

        print '(--interactive overrides --jobs)'

        options.jobs = 1

    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',

                                             warn=options.child is None)

    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 splitnewlines(text):

    '''like str.splitlines, but only split on newlines.

    keep line endings.'''

    i = 0

    lines = []

    while True:

        n = text.find('\n', i)

        if n == -1:

            last = text[i:]

            if last:

                lines.append(last)

            return lines

        lines.append(text[i:n + 1])

        i = n + 1

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

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

        sys.stdout.write(line)

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 checktools():

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

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

    for p in requiredtools:

        if os.name == 'nt':

            p += '.exe'

        found = findprogram(p)

        if found:

            vlog("# Found prerequisite", p, "at", found)

        else:

            print "WARNING: Did not find prerequisite tool: "+p

def terminate(proc):

    """Terminate subprocess (with fallback for Python versions < 2.6)"""

    vlog('# Terminating process %d' % proc.pid)

    try:

        getattr(proc, 'terminate', lambda : os.kill(proc.pid, signal.SIGTERM))()

    except OSError:

        pass

def killdaemons():

    # Kill off any leftover daemon processes

    try:

        fp = open(DAEMON_PIDS)

        for line in fp:

            try:

                pid = int(line)

            except ValueError:

                continue

            try:

                os.kill(pid, 0)

                vlog('# Killing daemon process %d' % pid)

                os.kill(pid, signal.SIGTERM)

                time.sleep(0.25)

                os.kill(pid, 0)

                vlog('# Daemon process %d is stuck - really killing it' % pid)

                os.kill(pid, signal.SIGKILL)

            except OSError, err:

                if err.errno != errno.ESRCH:

                    raise

        fp.close()

        os.unlink(DAEMON_PIDS)

    except IOError:

        pass

def cleanup(options):

    if not options.keep_tmpdir:

        vlog("# Cleaning up HGTMP", HGTMP)

        shutil.rmtree(HGTMP, True)

def usecorrectpython():

    # some tests run python interpreter. they must use same

    # interpreter we use or bad things will happen.

    exedir, exename = os.path.split(sys.executable)

    if exename in ('python', 'python.exe'):