[analyzer] [tests] Test different projects concurrently

[NoQ]

All right, so we have multiprocessing SATestBuild to run multiprocessing scan-build that intercepts the multiprocessing buildsystem, nice gj =)

Does it get interrupted gracefully with Ctrl+C?

utils/analyzer/SATestBuild.py

750–754

Does this really need a separate code path?

[george.karpenkov]

All right, so we have multiprocessing SATestBuild

No, it's multithreaded.
That's why logging to stdin/stderr from multiple projects at the same time works (python logging is thread-safe).

Does it get interrupted gracefully with Ctrl+C?

Yeah I went to some trouble to make sure it does: all threads are daemon threads, so killing the main thread suffices.

utils/analyzer/SATestBuild.py

750–754

I wanted to ensure no multithreaded stuff accidentally kicks in, but now that you're asking I guess it could be changed.

[NoQ]

Great.

[george.karpenkov]

...and the previous version was way to good to be true.

Turns out, the -j argument was not honored, and I had to actually implement a simple threading pool.
Additionally, logging was racing, and the "print" calls had to be replaced.

[george.karpenkov]

Fix global/local variable collision.

[george.karpenkov]

Better variable name.

[NoQ]

Ew, i need to look at stuff more carefully :) Anyway, it still looks good.

utils/analyzer/SATestBuild.py

729–730

Yeah, despite using an undocumented feature, i guess it's the most pythonic way of doing this we currently have.

utils/analyzer/SATestBuild.py

 
 The list of checkers tested are hardcoded in the Checkers variable.
 For testing additional checkers, use the SA_ADDITIONAL_CHECKERS environment
 variable. It should contain a comma separated list.
 """
 import CmpRuns
 import SATestUtils
 
-import os
+from subprocess import CalledProcessError, check_call
+import argparse
 import csv
-import sys
 import glob
+import logging
 import math
+import multiprocessing
+import os
+import plistlib
 import shutil
+import sys
+import threading
 import time
-import plistlib
-import argparse
-from subprocess import check_call, CalledProcessError
-import multiprocessing
+import Queue
 
 #------------------------------------------------------------------------------
 # Helper functions.
 #------------------------------------------------------------------------------
 
+Local = threading.local()
+Local.stdout = sys.stdout
+Local.stderr = sys.stderr
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s:%(levelname)s:%(name)s:%(message)s')
+
+class StreamToLogger(object):
+    def __init__(self, logger, log_level=logging.INFO):
+        self.logger = logger
+        self.log_level = log_level
+
+    def write(self, buf):
+        # Rstrip in order not to write an extra newline.
+        self.logger.log(self.log_level, buf.rstrip())
 
-sys.stdout = SATestUtils.flushfile(sys.stdout)
+    def flush(self):
+        pass
+
+    def fileno(self):
+        return 0
 
 
 def getProjectMapPath():
     ProjectMapPath = os.path.join(os.path.abspath(os.curdir),
                                   ProjectMapFile)
     if not os.path.exists(ProjectMapPath):
-        print "Error: Cannot find the Project Map file " + ProjectMapPath +\
-              "\nRunning script for the wrong directory?"
+        Local.stdout.write("Error: Cannot find the Project Map file "
+                           + ProjectMapPath
+                           + "\nRunning script for the wrong directory?\n")
         sys.exit(1)
     return ProjectMapPath
 
 
 def getProjectDir(ID):
     return os.path.join(os.path.abspath(os.curdir), ID)
 
 
if 'CC' in os.environ:
     Clang = os.environ['CC']
 else:
     Clang = SATestUtils.which("clang", os.environ['PATH'])
 if not Clang:
     print "Error: cannot find 'clang' in PATH"
     sys.exit(1)
 
 # Number of jobs.
-Jobs = int(math.ceil(multiprocessing.cpu_count() * 0.75))
+MaxJobs = int(math.ceil(multiprocessing.cpu_count() * 0.75))
 
 # Project map stores info about all the "registered" projects.
 ProjectMapFile = "projectMap.csv"
 
 # Names of the project specific scripts.
 # The script that downloads the project.
 DownloadScript = "download_project.sh"
 # The script that needs to be executed before the build can start.

 
 
 def runCleanupScript(Dir, PBuildLogFile):
     """
     Run pre-processing script if any.
     """
     Cwd = os.path.join(Dir, PatchedSourceDirName)
     ScriptPath = os.path.join(Dir, CleanupScript)
-    SATestUtils.runScript(ScriptPath, PBuildLogFile, Cwd)
+    SATestUtils.runScript(ScriptPath, PBuildLogFile, Cwd,
+                          Stdout=Local.stdout, Stderr=Local.stderr)
 
 
 def runDownloadScript(Dir, PBuildLogFile):
     """
     Run the script to download the project, if it exists.
     """
     ScriptPath = os.path.join(Dir, DownloadScript)
-    SATestUtils.runScript(ScriptPath, PBuildLogFile, Dir)
+    SATestUtils.runScript(ScriptPath, PBuildLogFile, Dir,
+                          Stdout=Local.stdout, Stderr=Local.stderr)
 
 
 def downloadAndPatch(Dir, PBuildLogFile):
     """
     Download the project and apply the local patchfile if it exists.
     """
     CachedSourceDirPath = os.path.join(Dir, CachedSourceDirName)
 
     # If the we don't already have the cached source, run the project's
     # download script to download it.
     if not os.path.exists(CachedSourceDirPath):
         runDownloadScript(Dir, PBuildLogFile)
         if not os.path.exists(CachedSourceDirPath):
-            print "Error: '%s' not found after download." % (
-                  CachedSourceDirPath)
+            Local.stderr.write("Error: '%s' not found after download.\n" % (
+                               CachedSourceDirPath))
             exit(1)
 
     PatchedSourceDirPath = os.path.join(Dir, PatchedSourceDirName)
 
     # Remove potentially stale patched source.
     if os.path.exists(PatchedSourceDirPath):
         shutil.rmtree(PatchedSourceDirPath)
 
     # Copy the cached source and apply any patches to the copy.
     shutil.copytree(CachedSourceDirPath, PatchedSourceDirPath, symlinks=True)
     applyPatch(Dir, PBuildLogFile)
 
 
 def applyPatch(Dir, PBuildLogFile):
     PatchfilePath = os.path.join(Dir, PatchfileName)
     PatchedSourceDirPath = os.path.join(Dir, PatchedSourceDirName)
     if not os.path.exists(PatchfilePath):
-        print "  No local patches."
+        Local.stdout.write("  No local patches.\n")
         return
 
-    print "  Applying patch."
+    Local.stdout.write("  Applying patch.\n")
     try:
         check_call("patch -p1 < '%s'" % (PatchfilePath),
                    cwd=PatchedSourceDirPath,
                    stderr=PBuildLogFile,
                    stdout=PBuildLogFile,
                    shell=True)
     except:
-        print "Error: Patch failed. See %s for details." % (PBuildLogFile.name)
+        Local.stderr.write("Error: Patch failed. See %s for details.\n" % (
+            PBuildLogFile.name))
         sys.exit(1)
 
 
 def runScanBuild(Dir, SBOutputDir, PBuildLogFile):
     """
     Build the project with scan-build by reading in the commands and
     prefixing them with the scan-build options.
     """
     BuildScriptPath = os.path.join(Dir, BuildScript)
     if not os.path.exists(BuildScriptPath):
-        print "Error: build script is not defined: %s" % BuildScriptPath
+        Local.stderr.write(
+            "Error: build script is not defined: %s\n" % BuildScriptPath)
         sys.exit(1)
 
     AllCheckers = Checkers
     if 'SA_ADDITIONAL_CHECKERS' in os.environ:
         AllCheckers = AllCheckers + ',' + os.environ['SA_ADDITIONAL_CHECKERS']
 
     # Run scan-build from within the patched source directory.
     SBCwd = os.path.join(Dir, PatchedSourceDirName)
try:
             Command = Command.strip()
             if len(Command) == 0:
                 continue
             # If using 'make', auto imply a -jX argument
             # to speed up analysis.  xcodebuild will
             # automatically use the maximum number of cores.
             if (Command.startswith("make ") or Command == "make") and \
                     "-j" not in Command:
-                Command += " -j%d" % Jobs
+                Command += " -j%d" % MaxJobs
             SBCommand = SBPrefix + Command
+
             if Verbose == 1:
-                print "  Executing: %s" % (SBCommand,)
+                Local.stdout.write("  Executing: %s\n" % (SBCommand,))
             check_call(SBCommand, cwd=SBCwd,
                        stderr=PBuildLogFile,
                        stdout=PBuildLogFile,
                        shell=True)
     except CalledProcessError:
-        print "Error: scan-build failed. Its output was: "
+        Local.stderr.write("Error: scan-build failed. Its output was: \n")
         PBuildLogFile.seek(0)
-        shutil.copyfileobj(PBuildLogFile, sys.stdout)
+        shutil.copyfileobj(PBuildLogFile, Local.stderr)
         sys.exit(1)
 
 
 def runAnalyzePreprocessed(Dir, SBOutputDir, Mode):
     """
     Run analysis on a set of preprocessed files.
     """
     if os.path.exists(os.path.join(Dir, BuildScript)):
-        print "Error: The preprocessed files project should not contain %s" % \
-              BuildScript
+        Local.stderr.write(
+            "Error: The preprocessed files project should not contain %s\n" % (
+                BuildScript))
         raise Exception()
 
     CmdPrefix = Clang + " -cc1 "
 
     # For now, we assume the preprocessed files should be analyzed
     # with the OS X SDK.
     SDKPath = SATestUtils.getSDKPath("macosx")
     if SDKPath is not None:
def runAnalyzePreprocessed(Dir, SBOutputDir, Mode):
     for FullFileName in glob.glob(Dir + "/*"):
         FileName = os.path.basename(FullFileName)
         Failed = False
 
         # Only run the analyzes on supported files.
         if SATestUtils.hasNoExtension(FileName):
             continue
         if not SATestUtils.isValidSingleInputFile(FileName):
-            print "Error: Invalid single input file %s." % (FullFileName,)
+            Local.stderr.write(
+                "Error: Invalid single input file %s.\n" % (FullFileName,))
             raise Exception()
 
         # Build and call the analyzer command.
         OutputOption = "-o '%s.plist' " % os.path.join(PlistPath, FileName)
         Command = CmdPrefix + OutputOption + ("'%s'" % FileName)
         LogFile = open(os.path.join(FailPath, FileName + ".stderr.txt"), "w+b")
         try:
             if Verbose == 1:
-                print "  Executing: %s" % (Command,)
+                Local.stdout.write("  Executing: %s\n" % (Command,))
             check_call(Command, cwd=Dir, stderr=LogFile,
                        stdout=LogFile,
                        shell=True)
         except CalledProcessError, e:
-            print "Error: Analyzes of %s failed. See %s for details." \
-                  "Error code %d." % (
-                      FullFileName, LogFile.name, e.returncode)
+            Local.stderr.write("Error: Analyzes of %s failed. "
+                               "See %s for details."
+                               "Error code %d.\n" % (
+                                   FullFileName, LogFile.name, e.returncode))
             Failed = True
         finally:
             LogFile.close()
 
         # If command did not fail, erase the log file.
         if not Failed:
             os.remove(LogFile.name)
 
 
 def getBuildLogPath(SBOutputDir):
     return os.path.join(SBOutputDir, LogFolderName, BuildLogName)
 
 
 def removeLogFile(SBOutputDir):
     BuildLogPath = getBuildLogPath(SBOutputDir)
     # Clean up the log file.
     if (os.path.exists(BuildLogPath)):
         RmCommand = "rm '%s'" % BuildLogPath
         if Verbose == 1:
-            print "  Executing: %s" % (RmCommand,)
+            Local.stdout.write("  Executing: %s\n" % (RmCommand,))
         check_call(RmCommand, shell=True)
 
 
 def buildProject(Dir, SBOutputDir, ProjectBuildMode, IsReferenceBuild):
     TBegin = time.time()
 
     BuildLogPath = getBuildLogPath(SBOutputDir)
-    print "Log file: %s" % (BuildLogPath,)
-    print "Output directory: %s" % (SBOutputDir, )
+    Local.stdout.write("Log file: %s\n" % (BuildLogPath,))
+    Local.stdout.write("Output directory: %s\n" % (SBOutputDir, ))
 
     removeLogFile(SBOutputDir)
 
     # Clean up scan build results.
     if (os.path.exists(SBOutputDir)):
         RmCommand = "rm -r '%s'" % SBOutputDir
         if Verbose == 1:
-            print "  Executing: %s" % (RmCommand,)
-            check_call(RmCommand, shell=True)
+            Local.stdout.write("  Executing: %s\n" % (RmCommand,))
+            check_call(RmCommand, shell=True, stdout=Local.stdout,
+                       stderr=Local.stderr)
     assert(not os.path.exists(SBOutputDir))
     os.makedirs(os.path.join(SBOutputDir, LogFolderName))
 
     # Build and analyze the project.
     with open(BuildLogPath, "wb+") as PBuildLogFile:
         if (ProjectBuildMode == 1):
             downloadAndPatch(Dir, PBuildLogFile)
             runCleanupScript(Dir, PBuildLogFile)
             runScanBuild(Dir, SBOutputDir, PBuildLogFile)
         else:
             runAnalyzePreprocessed(Dir, SBOutputDir, ProjectBuildMode)
 
         if IsReferenceBuild:
             runCleanupScript(Dir, PBuildLogFile)
             normalizeReferenceResults(Dir, SBOutputDir, ProjectBuildMode)
 
-    print "Build complete (time: %.2f). See the log for more details: %s" % \
-          ((time.time() - TBegin), BuildLogPath)
+    Local.stdout.write("Build complete (time: %.2f). "
+                       "See the log for more details: %s\n" % (
+                           (time.time() - TBegin), BuildLogPath))
 
 
 def normalizeReferenceResults(Dir, SBOutputDir, ProjectBuildMode):
     """
     Make the absolute paths relative in the reference results.
     """
     for (DirPath, Dirnames, Filenames) in os.walk(SBOutputDir):
         for F in Filenames:
def checkBuild(SBOutputDir):
     """
     # Check if there are failures.
     Failures = glob.glob(SBOutputDir + "/*/failures/*.stderr.txt")
     TotalFailed = len(Failures)
     if TotalFailed == 0:
         CleanUpEmptyPlists(SBOutputDir)
         CleanUpEmptyFolders(SBOutputDir)
         Plists = glob.glob(SBOutputDir + "/*/*.plist")
-        print "Number of bug reports (non-empty plist files) produced: %d" %\
-            len(Plists)
+        Local.stdout.write(
+            "Number of bug reports (non-empty plist files) produced: %d\n" %
+            len(Plists))
         return
 
-    print "Error: analysis failed."
-    print "Total of %d failures discovered." % TotalFailed
+    Local.stderr.write("Error: analysis failed.\n")
+    Local.stderr.write("Total of %d failures discovered.\n" % TotalFailed)
     if TotalFailed > NumOfFailuresInSummary:
-        print "See the first %d below.\n" % NumOfFailuresInSummary
+        Local.stderr.write(
+            "See the first %d below.\n" % NumOfFailuresInSummary)
         # TODO: Add a line "See the results folder for more."
 
     Idx = 0
     for FailLogPathI in Failures:
         if Idx >= NumOfFailuresInSummary:
             break
         Idx += 1
-        print "\n-- Error #%d -----------\n" % Idx
+        Local.stderr.write("\n-- Error #%d -----------\n" % Idx)
         with open(FailLogPathI, "r") as FailLogI:
-            shutil.copyfileobj(FailLogI, sys.stdout)
+            shutil.copyfileobj(FailLogI, Local.stdout)
 
     sys.exit(1)
 
 
 def runCmpResults(Dir, Strictness=0):
     """
     Compare the warnings produced by scan-build.
     Strictness defines the success criteria for the test:
def runCmpResults(Dir, Strictness=0):
     NumDiffs = 0
     PairList = zip(RefList, NewList)
     for P in PairList:
         RefDir = P[0]
         NewDir = P[1]
 
         assert(RefDir != NewDir)
         if Verbose == 1:
-            print "  Comparing Results: %s %s" % (RefDir, NewDir)
+            Local.stdout.write("  Comparing Results: %s %s\n" % (
+                               RefDir, NewDir))
 
         PatchedSourceDirPath = os.path.join(Dir, PatchedSourceDirName)
         Opts = CmpRuns.CmpOptions(rootA="", rootB=PatchedSourceDirPath)
         # Scan the results, delete empty plist files.
         NumDiffs, ReportsInRef, ReportsInNew = \
             CmpRuns.dumpScanBuildResultsDiff(RefDir, NewDir, Opts, False)
         if (NumDiffs > 0):
-            print "Warning: %s differences in diagnostics." % NumDiffs
+            Local.stdout.write("Warning: %s differences in diagnostics.\n"
+                               % NumDiffs)
         if Strictness >= 2 and NumDiffs > 0:
-            print "Error: Diffs found in strict mode (2)."
+            Local.stdout.write("Error: Diffs found in strict mode (2).\n")
             TestsPassed = False
         elif Strictness >= 1 and ReportsInRef != ReportsInNew:
-            print "Error: The number of results are different in "\
-                  "strict mode (1)."
+            Local.stdout.write("Error: The number of results are different " +
+                               " strict mode (1).\n")
             TestsPassed = False
 
-    print "Diagnostic comparison complete (time: %.2f)." % (
-          time.time() - TBegin)
+    Local.stdout.write("Diagnostic comparison complete (time: %.2f).\n" % (
+                       time.time() - TBegin))
     return TestsPassed
 
 
 def cleanupReferenceResults(SBOutputDir):
     """
     Delete html, css, and js files from reference results. These can
     include multiple copies of the benchmark source and so get very large.
     """
     Extensions = ["html", "css", "js"]
     for E in Extensions:
         for F in glob.glob("%s/*/*.%s" % (SBOutputDir, E)):
             P = os.path.join(SBOutputDir, F)
             RmCommand = "rm '%s'" % P
             check_call(RmCommand, shell=True)
 
     # Remove the log file. It leaks absolute path names.
     removeLogFile(SBOutputDir)
 
 
+class TestProjectThread(threading.Thread):
+    def __init__(self, TasksQueue, ResultsDiffer, FailureFlag):
+        """
+        :param ResultsDiffer: Used to signify that results differ from
+        canonical one.
+        :param FailureFlag: Used to signify failure during the run.
+        """
+        self.TasksQueue = TasksQueue
+        self.ResultsDiffer = ResultsDiffer
+        self.FailureFlag = FailureFlag
+        super(TestProjectThread, self).__init__()
+
+        # Needed to gracefully handle interrupts with Ctrl-C
+        self.daemon = True
+
+    def run(self):
+        while not self.TasksQueue.empty():
+            try:
+                ProjArgs = self.TasksQueue.get()
+                Name = ProjArgs[0]
+                Logger = logging.getLogger(Name)
+                Local.stdout = StreamToLogger(Logger, logging.INFO)
+                Local.stderr = StreamToLogger(Logger, logging.ERROR)
+                if not testProject(*ProjArgs):
+                    self.ResultsDiffer.set()
+                self.TasksQueue.task_done()
+            except:
+                self.FailureFlag.set()
+                raise
+
+
 def testProject(ID, ProjectBuildMode, IsReferenceBuild=False, Strictness=0):
     """
     Test a given project.
     :return TestsPassed: Whether tests have passed according
     to the :param Strictness: criteria.
     """
-    print " \n\n--- Building project %s" % (ID,)
+    Local.stdout.write(" \n\n--- Building project %s\n" % (ID,))
 
     TBegin = time.time()
 
     Dir = getProjectDir(ID)
     if Verbose == 1:
-        print "  Build directory: %s." % (Dir,)
+        Local.stdout.write("  Build directory: %s.\n" % (Dir,))
 
     # Set the build results directory.
     RelOutputDir = getSBOutputDirName(IsReferenceBuild)
     SBOutputDir = os.path.join(Dir, RelOutputDir)
 
     buildProject(Dir, SBOutputDir, ProjectBuildMode, IsReferenceBuild)
 
     checkBuild(SBOutputDir)
 
     if IsReferenceBuild:
         cleanupReferenceResults(SBOutputDir)
         TestsPassed = True
     else:
         TestsPassed = runCmpResults(Dir, Strictness)
 
-    print "Completed tests for project %s (time: %.2f)." % \
-          (ID, (time.time() - TBegin))
+    Local.stdout.write("Completed tests for project %s (time: %.2f).\n" % (
+                       ID, (time.time() - TBegin)))
     return TestsPassed
 
 
 def projectFileHandler():
     return open(getProjectMapPath(), "rb")
 
 
 def iterateOverProjects(PMapFile):
for I in iterateOverProjects(PMapFile):
         if len(I) != 2:
             print "Error: Rows in the ProjectMapFile should have 2 entries."
             raise Exception()
         if I[1] not in ('0', '1', '2'):
             print "Error: Second entry in the ProjectMapFile should be 0" \
                   " (single file), 1 (project), or 2(single file c++11)."
             raise Exception()
 
+def singleThreadedTestAll(ProjectsToTest):
+    """
+    Run all projects.
+    :return: whether tests have passed.
+    """
+    Success = True
+    for ProjArgs in ProjectsToTest:
+        Success &= testProject(*ProjArgs)
+    return Success
+
+def multiThreadedTestAll(ProjectsToTest, Jobs):
+    """
+    Run each project in a separate thread.
+
+    This is OK despite GIL, as testing is blocked
+    on launching external processes.
+
+    :return: whether tests have passed.
+    """
+    TasksQueue = Queue.Queue()
+
+    for ProjArgs in ProjectsToTest:
+        TasksQueue.put(ProjArgs)
+
+    ResultsDiffer = threading.Event()
+    FailureFlag = threading.Event()
+
+    for i in range(Jobs):
+        T = TestProjectThread(TasksQueue, ResultsDiffer, FailureFlag)
+        T.start()
+
+    # Required to handle Ctrl-C gracefully.
+    while TasksQueue.unfinished_tasks:
+        time.sleep(0.1)  # Seconds.
+        if FailureFlag.is_set():
+            Local.stderr.write("Test runner crashed\n")
+            sys.exit(1)
+    return not ResultsDiffer.is_set()
+
+
+def testAll(Args):
+    ProjectsToTest = []
 
-def testAll(IsReferenceBuild=False, Strictness=0):
-    TestsPassed = True
     with projectFileHandler() as PMapFile:
         validateProjectFile(PMapFile)
 
         # Test the projects.
         for (ProjName, ProjBuildMode) in iterateOverProjects(PMapFile):
-            TestsPassed &= testProject(
-                ProjName, int(ProjBuildMode), IsReferenceBuild, Strictness)
-    return TestsPassed
+            ProjectsToTest.append((ProjName,
+                                  int(ProjBuildMode),
+                                  Args.regenerate,
+                                  Args.strictness))
+    if Args.jobs <= 1:
+        return singleThreadedTestAll(ProjectsToTest)
+    else:
+        return multiThreadedTestAll(ProjectsToTest, Args.jobs)
 
 
 if __name__ == '__main__':
     # Parse command line arguments.
     Parser = argparse.ArgumentParser(
         description='Test the Clang Static Analyzer.')
     Parser.add_argument('--strictness', dest='strictness', type=int, default=0,
                         help='0 to fail on runtime errors, 1 to fail when the \
                              number of found bugs are different from the \
                              reference, 2 to fail on any difference from the \
                              reference. Default is 0.')
     Parser.add_argument('-r', dest='regenerate', action='store_true',
                         default=False, help='Regenerate reference output.')
+    Parser.add_argument('-j', '--jobs', dest='jobs', type=int,
+                        default=0,
+                        help='Number of projects to test concurrently')
     Args = Parser.parse_args()
 
-    IsReference = False
-    Strictness = Args.strictness
-    if Args.regenerate:
-        IsReference = True
-
-    TestsPassed = testAll(IsReference, Strictness)
+    TestsPassed = testAll(Args)
     if not TestsPassed:
         print "ERROR: Tests failed."
         sys.exit(42)

utils/analyzer/SATestUtils.py

for path in paths.split(os.pathsep):
         for ext in pathext:
             p = os.path.join(path, command + ext)
             if os.path.exists(p):
                 return p
 
     return None
 
 
-class flushfile(object):
-    """
-    Wrapper to flush the output after every print statement.
-    """
-    def __init__(self, f):
-        self.f = f
-
-    def write(self, x):
-        self.f.write(x)
-        self.f.flush()
-
-
 def hasNoExtension(FileName):
     (Root, Ext) = os.path.splitext(FileName)
     return (Ext == "")
 
 
 def isValidSingleInputFile(FileName):
     (Root, Ext) = os.path.splitext(FileName)
     return Ext in (".i", ".ii", ".c", ".cpp", ".m", "")
 
 
 def getSDKPath(SDKName):
     """
     Get the path to the SDK for the given SDK name. Returns None if
     the path cannot be determined.
     """
     if which("xcrun") is None:
         return None
 
     Cmd = "xcrun --sdk " + SDKName + " --show-sdk-path"
     return check_output(Cmd, shell=True).rstrip()
 
 
-def runScript(ScriptPath, PBuildLogFile, Cwd):
+def runScript(ScriptPath, PBuildLogFile, Cwd, Stdout=sys.stdout,
+              Stderr=sys.stderr):
     """
     Run the provided script if it exists.
     """
     if os.path.exists(ScriptPath):
         try:
             if Verbose == 1:
-                print "  Executing: %s" % (ScriptPath,)
+                Stdout.write("  Executing: %s\n" % (ScriptPath,))
             check_call("chmod +x '%s'" % ScriptPath, cwd=Cwd,
                        stderr=PBuildLogFile,
                        stdout=PBuildLogFile,
                        shell=True)
             check_call("'%s'" % ScriptPath, cwd=Cwd,
                        stderr=PBuildLogFile,
                        stdout=PBuildLogFile,
                        shell=True)
         except:
-            print "Error: Running %s failed. See %s for details." % (
-                  ScriptPath, PBuildLogFile.name)
+            Stderr.write("Error: Running %s failed. See %s for details.\n" % (
+                         ScriptPath, PBuildLogFile.name))
             sys.exit(-1)
 
 
 def isCommentCSVLine(Entries):
     """
     Treat CSV lines starting with a '#' as a comment.
     """
     return len(Entries) > 0 and Entries[0].startswith("#")