| #!/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 sys |
| import tempfile |
| |
| from subprocess import call |
| from shutil import rmtree |
| |
| import logging |
| import unittest |
| |
| |
| def banner(): |
| """ |
| Display interpreter and system info for the test env |
| """ |
| print '*' * 75 |
| cmd = os.path.basename(__file__) |
| print "%s: python version is %s" % (cmd, sys.version) |
| print '*' * 75 |
| |
| |
| def myopts(vals): |
| """ |
| Storage for extra command line args passed. |
| |
| Returns: |
| hash - argparse::Namespace object values |
| """ |
| |
| if not hasattr(myopts, 'vals'): |
| if 'argparse' in sys.modules: |
| tmp = { } # key existance enables unittest module debug |
| else: |
| tmp = { 'debug': False, 'verbose': False } |
| |
| for k in dir(vals): |
| if k[0:1] == '_': |
| continue |
| tmp[k] = getattr(vals, k) |
| myopts.vals = tmp |
| |
| return myopts.vals |
| |
| |
| def path2posix(src): |
| """ |
| Normalize directory path syntax |
| |
| Keyword arguments: |
| src - path to normalize |
| |
| Returns: |
| scalar - a file path with drive separators and windows slashes removed |
| |
| Todo: |
| move to {build,config,tools,toolkit}/python for use in a library |
| """ |
| |
| ## (drive, tail) = os.path.splitdrive(src) |
| ## Support path testing on all platforms |
| drive = '' |
| winpath = src.find(':') |
| if -1 != winpath and 10 > winpath: |
| (drive, tail) = src.split(':', 1) |
| |
| if drive: |
| todo = [ '', drive.rstrip(':').lstrip('/').lstrip('\\') ] |
| todo.extend( tail.lstrip('/').lstrip('\\').split('\\') ) # c:\a => [a] |
| else: # os.name == 'posix' |
| todo = src.split('\\') |
| |
| dst = '/'.join(todo) |
| return dst |
| |
| |
| def checkMkdir(work, debug=False): |
| """ |
| Verify arg permutations for directory mutex creation. |
| |
| Keyword arguments: |
| None |
| |
| Returns: |
| Exception on error |
| |
| Note: |
| Exception() rather than self.assertTrue() is used in this test |
| function to enable scatch cleanup on test exit/failure conditions. |
| Not guaranteed by python closures on early exit. |
| """ |
| |
| logging.debug("Testing: checkMkdir") |
| |
| # On Windows, don't convert paths to POSIX |
| skipposix = sys.platform == "win32" |
| if skipposix: |
| path = os.path.abspath(__file__) |
| dirname_fun = os.path.dirname |
| else: |
| path = path2posix(os.path.abspath(__file__)) |
| import posixpath |
| dirname_fun = posixpath.dirname |
| |
| src = dirname_fun(path) |
| # root is 5 directories up from path |
| root = reduce(lambda x, _: dirname_fun(x), xrange(5), path) |
| |
| rootP = path2posix(root) |
| srcP = path2posix(src) |
| workP = path2posix(work) |
| |
| # C:\foo -vs- /c/foo |
| # [0] command paths use /c/foo |
| # [1] os.path.exists() on mingw() requires C:\ |
| paths = [ |
| "mkdir_bycall", # function generated |
| "mkdir_bydep", # explicit dependency |
| "mkdir_bygen", # by GENERATED_DIRS macro |
| ] |
| |
| ## Use make from the parent "make check" call when available |
| cmd = { 'make': 'make' } |
| shell0 = os.environ.get('MAKE') |
| if shell0: |
| shell = os.path.splitext(shell0)[0] # strip: .exe, .py |
| if -1 != shell.find('make'): |
| print "MAKE COMMAND FOUND: %s" % (shell0) |
| cmd['make'] = shell0 if skipposix else path2posix(shell0) |
| |
| args = [] |
| args.append('%s' % (cmd['make'])) |
| args.append('-C %s' % (work if skipposix else workP)) |
| args.append("-f %s/testor.tmpl" % (src if skipposix else srcP)) |
| args.append('topsrcdir=%s' % (root if skipposix else rootP)) |
| args.append('deps_mkdir_bycall=%s' % paths[0]) |
| args.append('deps_mkdir_bydep=%s' % paths[1]) |
| args.append('deps_mkdir_bygen=%s' % paths[2]) |
| args.append('checkup') # target |
| |
| # Call will fail on mingw with output redirected ?!? |
| if debug: |
| pass |
| if False: # if not debug: |
| args.append('>/dev/null') |
| |
| cmd = '%s' % (' '.join(args)) |
| logging.debug("Running: %s" % (cmd)) |
| rc = call(cmd, shell=True) |
| if rc: |
| raise Exception("make failed ($?=%s): cmd=%s" % (rc, cmd)) |
| |
| for i in paths: |
| path = os.path.join(work, i) |
| logging.debug("Did testing mkdir(%s) succeed?" % (path)) |
| if not os.path.exists(path): |
| raise Exception("Test path %s does not exist" % (path)) |
| |
| |
| def parseargs(): |
| """ |
| Support additional command line arguments for testing |
| |
| Returns: |
| hash - arguments of interested parsed from the command line |
| """ |
| |
| opts = None |
| try: |
| import argparse2 |
| parser = argparse.ArgumentParser() |
| parser.add_argument('--debug', |
| action="store_true", |
| default=False, |
| help='Enable debug mode') |
| # Cannot overload verbose, Verbose: False enables debugging |
| parser.add_argument('--verbose', |
| action="store_true", |
| default=False, |
| help='Enable verbose mode') |
| parser.add_argument('unittest_args', |
| nargs='*' |
| # help='Slurp/pass remaining args to unittest' |
| ) |
| opts = parser.parse_args() |
| |
| except ImportError: |
| pass |
| |
| return opts |
| |
| |
| class TestMakeLogic(unittest.TestCase): |
| """ |
| Test suite used to validate makefile library rules and macros |
| """ |
| |
| def setUp(self): |
| opts = myopts(None) # NameSpace object not hash |
| self.debug = opts['debug'] |
| self.verbose = opts['verbose'] |
| |
| if self.debug: |
| logging.basicConfig(level=logging.DEBUG) |
| |
| if self.verbose: |
| print |
| print "ENVIRONMENT DUMP:" |
| print '=' * 75 |
| for k,v in os.environ.items(): |
| print "env{%s} => %s" % (k, v) |
| print |
| |
| |
| def test_path2posix(self): |
| |
| todo = { |
| '/dev/null' : '/dev/null', |
| 'A:\\a\\b\\c' : '/A/a/b/c', |
| 'B:/x/y' : '/B/x/y', |
| 'C:/x\\y/z' : '/C/x/y/z', |
| '//FOO/bar/tans': '//FOO/bar/tans', |
| '//X\\a/b\\c/d' : '//X/a/b/c/d', |
| '\\c:mozilla\\sandbox': '/c/mozilla/sandbox', |
| } |
| |
| for val,exp in todo.items(): |
| found = path2posix(val) |
| tst = "posix2path(%s): %s != %s)" % (val, exp, found) |
| self.assertEqual(exp, found, "%s: invalid path detected" % (tst)) |
| |
| |
| def test_mkdir(self): |
| """ |
| Verify directory creation rules and macros |
| """ |
| |
| failed = True |
| |
| # Exception handling is used to cleanup scratch space on error |
| try: |
| work = tempfile.mkdtemp() |
| checkMkdir(work, self.debug) |
| failed = False |
| finally: |
| if os.path.exists(work): |
| rmtree(work) |
| |
| self.assertFalse(failed, "Unit test failure detected") |
| |
| |
| if __name__ == '__main__': |
| banner() |
| opts = parseargs() |
| myopts(opts) |
| |
| if opts: |
| if hasattr(opts, 'unittest_args'): |
| sys.argv[1:] = opts.unittest_args |
| else: |
| sys.argv[1:] = [] |
| |
| unittest.main() |
