DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (dcc6d7a0dc00)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
#!/usr/bin/env python

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.

import os
import subprocess
import sys
import unittest
import proctest
from mozprocess import processhandler

here = os.path.dirname(os.path.abspath(__file__))

def make_proclaunch(aDir):
    """
        Makes the proclaunch executable.
        Params:
            aDir - the directory in which to issue the make commands
        Returns:
            the path to the proclaunch executable that is generated
    """

    if sys.platform == "win32":
        exepath = os.path.join(aDir, "proclaunch.exe")
    else:
        exepath = os.path.join(aDir, "proclaunch")

    # remove the launcher, if it already exists
    # otherwise, if the make fails you may not notice
    if os.path.exists(exepath):
        os.remove(exepath)

    # Ideally make should take care of both calls through recursion, but since it doesn't,
    # on windows anyway (to file?), let's just call out both targets explicitly.
    for command in [["make", "-C", "iniparser"],
                    ["make"]]:
        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=aDir)
        stdout, stderr = process.communicate()
        if process.returncode:
            # SomethingBadHappen; print all the things
            print "%s: exit %d" % (command, process.returncode)
            print "stdout:\n%s" % stdout
            print "stderr:\n%s" % stderr
            raise subprocess.CalledProcessError(process.returncode, command, stdout)

    # ensure the launcher now exists
    if not os.path.exists(exepath):
        raise AssertionError("proclaunch executable '%s' does not exist (sys.platform=%s)" % (exepath, sys.platform))
    return exepath


class ProcTest(proctest.ProcTest):

    # whether to remove created files on exit
    cleanup = os.environ.get('CLEANUP', 'true').lower() in ('1', 'true')

    @classmethod
    def setUpClass(cls):
        cls.proclaunch = make_proclaunch(here)

    @classmethod
    def tearDownClass(cls):
        del cls.proclaunch
        if not cls.cleanup:
            return
        files = [('proclaunch',),
                 ('proclaunch.exe',),
                 ('iniparser', 'dictionary.o'),
                 ('iniparser', 'iniparser.lib'),
                 ('iniparser', 'iniparser.o'),
                 ('iniparser', 'libiniparser.a'),
                 ('iniparser', 'libiniparser.so.0'),
                 ]
        files = [os.path.join(here, *path) for path in files]
        errors = []
        for path in files:
            if os.path.exists(path):
                try:
                    os.remove(path)
                except OSError as e:
                    errors.append(str(e))
        if errors:
            raise OSError("Error(s) encountered tearing down %s.%s:\n%s" % (cls.__module__, cls.__name__, '\n'.join(errors)))

    def test_process_normal_finish(self):
        """Process is started, runs to completion while we wait for it"""

        p = processhandler.ProcessHandler([self.proclaunch, "process_normal_finish.ini"],
                                          cwd=here)
        p.run()
        p.wait()

        self.determine_status(p)

    def test_commandline_no_args(self):
        """Command line is reported correctly when no arguments are specified"""
        p = processhandler.ProcessHandler(self.proclaunch, cwd=here)
        self.assertEqual(p.commandline, self.proclaunch)

    def test_commandline_overspecified(self):
        """Command line raises an exception when the arguments are specified ambiguously"""
        err = None
        try:
            processhandler.ProcessHandler([self.proclaunch, "process_normal_finish.ini"],
                                          args=["1", "2", "3"],
                                          cwd=here)
        except TypeError, e:
            err = e

        self.assertTrue(err)

    def test_commandline_from_list(self):
        """Command line is reported correctly when command and arguments are specified in a list"""
        p = processhandler.ProcessHandler([self.proclaunch, "process_normal_finish.ini"],
                                          cwd=here)
        self.assertEqual(p.commandline, self.proclaunch + ' process_normal_finish.ini')

    def test_commandline_over_specified(self):
        """Command line raises an exception when the arguments are specified ambiguously"""
        err = None
        try:
            processhandler.ProcessHandler([self.proclaunch, "process_normal_finish.ini"],
                                          args=["1", "2", "3"],
                                          cwd=here)
        except TypeError, e:
            err = e

        self.assertTrue(err)

    def test_commandline_from_args(self):
        """Command line is reported correctly when arguments are specified in a dedicated list"""
        p = processhandler.ProcessHandler(self.proclaunch,
                                          args=["1", "2", "3"],
                                          cwd=here)
        self.assertEqual(p.commandline, self.proclaunch + ' 1 2 3')

    def test_process_wait(self):
        """Process is started runs to completion while we wait indefinitely"""

        p = processhandler.ProcessHandler([self.proclaunch,
                                          "process_waittimeout_10s.ini"],
                                          cwd=here)
        p.run()
        p.wait()

        self.determine_status(p)

    def test_process_timeout(self):
        """ Process is started, runs but we time out waiting on it
            to complete
        """
        p = processhandler.ProcessHandler([self.proclaunch, "process_waittimeout.ini"],
                                          cwd=here)
        p.run(timeout=10)
        p.wait()

        self.determine_status(p, False, ['returncode', 'didtimeout'])

    def test_process_timeout_no_kill(self):
        """ Process is started, runs but we time out waiting on it
            to complete. Process should not be killed.
        """
        p = None
        def timeout_handler():
            self.assertEqual(p.proc.poll(), None)
            p.kill()
        p = processhandler.ProcessHandler([self.proclaunch, "process_waittimeout.ini"],
                                          cwd=here,
                                          onTimeout=(timeout_handler,),
                                          kill_on_timeout=False)
        p.run(timeout=1)
        p.wait()
        self.assertTrue(p.didTimeout)

        self.determine_status(p, False, ['returncode', 'didtimeout'])

    def test_process_waittimeout(self):
        """
        Process is started, then wait is called and times out.
        Process is still running and didn't timeout
        """
        p = processhandler.ProcessHandler([self.proclaunch,
                                          "process_waittimeout_10s.ini"],
                                          cwd=here)

        p.run()
        p.wait(timeout=5)

        self.determine_status(p, True, ())

    def test_process_waitnotimeout(self):
        """ Process is started, runs to completion before our wait times out
        """
        p = processhandler.ProcessHandler([self.proclaunch,
                                          "process_waittimeout_10s.ini"],
                                          cwd=here)
        p.run(timeout=30)
        p.wait()

        self.determine_status(p)

    def test_process_kill(self):
        """Process is started, we kill it"""

        p = processhandler.ProcessHandler([self.proclaunch, "process_normal_finish.ini"],
                                          cwd=here)
        p.run()
        p.kill()

        self.determine_status(p)

    def test_process_output_twice(self):
        """
        Process is started, then processOutput is called a second time explicitly
        """
        p = processhandler.ProcessHandler([self.proclaunch,
                                          "process_waittimeout_10s.ini"],
                                          cwd=here)

        p.run()
        p.processOutput(timeout=5)
        p.wait()

        self.determine_status(p, False, ())


if __name__ == '__main__':
    unittest.main()