Make OSX test run firewall friendly.

[ovyalov]

Summary

When running tests on OSX I see a lot of firewall warnings about allowing lldb and some test binaries to listen for incoming connections - so, I have to turn firewall off.
With this CL in the test run should be silent with enabled firewall.
Use lldb_codesign certificate to sign lldb binary when building with XCode and codesign those test binaries which open the listen sockets.

[clayborg]

Looks good.

[Eugene.Zelenko]

Committed in r226856.

lldb.xcodeproj/project.pbxproj

26DC6A0F1337FE6900FF7998 /* lldb-platform */ = {
       productType = "com.apple.product-type.tool";
     };
     26F5C26910F3D9A4009D5894 /* lldb-tool */ = {
       isa = PBXNativeTarget;
       buildConfigurationList = 26F5C26E10F3D9C5009D5894 /* Build configuration list for PBXNativeTarget "lldb-tool" */;
       buildPhases = (
         26F5C26710F3D9A4009D5894 /* Sources */,
         26F5C26810F3D9A4009D5894 /* Frameworks */,
+        25ED0ED41A70979C00E3DA2E /* ShellScript */,
       );
       buildRules = (
       );
       dependencies = (
         266803621160110D008E1FE4 /* PBXTargetDependency */,
       );
       name = "lldb-tool";
       productName = lldb;
EDE274E714EDCE1F005B0F75 /* Resources */ = {
       buildActionMask = 2147483647;
       files = (
       );
       runOnlyForDeploymentPostprocessing = 0;
     };
 /* End PBXResourcesBuildPhase section */
 
 /* Begin PBXShellScriptBuildPhase section */
+    25ED0ED41A70979C00E3DA2E /* ShellScript */ = {
+      isa = PBXShellScriptBuildPhase;
+      buildActionMask = 2147483647;
+      files = (
+      );
+      inputPaths = (
+      );
+      outputPaths = (
+      );
+      runOnlyForDeploymentPostprocessing = 0;
+      shellPath = /bin/sh;
+      shellScript = "if [ \"${CONFIGURATION}\" != BuildAndIntegration ]\nthen\ncodesign -f -s lldb_codesign \"${TARGET_BUILD_DIR}/${PRODUCT_NAME}\"\nfi";
+    };
     261B5A7511C3FA6F00AABD0A /* Fixup Framework Headers */ = {
       isa = PBXShellScriptBuildPhase;
       buildActionMask = 2147483647;
       files = (
       );
       inputPaths = (
       );
       name = "Fixup Framework Headers";

test/api/multiple-debuggers/TestMultipleDebuggers.py

class TestMultipleSimultaneousDebuggers(TestBase):
     @expectedFailureFreeBSD("llvm.org/pr20282")
     @expectedFailureLinux("llvm.org/pr20282")
     def test_multiple_debuggers(self):
         env = {self.dylibPath : self.getLLDBLibraryEnvVal()}
 
         self.driver_exe = os.path.join(os.getcwd(), "multi-process-driver")
         self.buildDriver('multi-process-driver.cpp', self.driver_exe)
         self.addTearDownHook(lambda: os.remove(self.driver_exe))
+        self.signBinary(self.driver_exe)
 
         self.inferior_exe = os.path.join(os.getcwd(), "testprog")
         self.buildDriver('testprog.cpp', self.inferior_exe)
         self.addTearDownHook(lambda: os.remove(self.inferior_exe))
 
 # check_call will raise a CalledProcessError if multi-process-driver doesn't return
 # exit code 0 to indicate success.  We can let this exception go - the test harness
 # will recognize it as a test failure.

test/api/multithreaded/TestMultithreaded.py

def test_sb_api_listener_resume(self):
                             'test_listener_resume')
         pass
 
     def build_and_test(self, sources, test_name, args = None):
         """ Build LLDB test from sources, and run expecting 0 exit code """
         self.buildDriver(sources, test_name)
         self.addTearDownHook(lambda: os.remove(test_name))
 
-        exe = [os.path.join(os.getcwd(), test_name), self.inferior]
+        test_exe = os.path.join(os.getcwd(), test_name)
+        self.signBinary(test_exe)
+        exe = [test_exe, self.inferior]
 
         env = {self.dylibPath : self.getLLDBLibraryEnvVal()}
         if self.TraceOn():
             print "Running test %s" % " ".join(exe)
             check_call(exe, env=env)
         else:
             with open(os.devnull, 'w') as fnull:
                 check_call(exe, env=env, stdout=fnull, stderr=fnull)

test/lldbtest.py

class Base(unittest2.TestCase):
     def buildDwarf(self, architecture=None, compiler=None, dictionary=None, clean=True):
         """Platform specific way to build binaries with dwarf maps."""
         if lldb.skip_build_and_cleanup:
             return
         module = builder_module()
         if not module.buildDwarf(self, architecture, compiler, dictionary, clean):
             raise Exception("Don't know how to build binary with dwarf")
 
+    def signBinary(self, binary_path):
+        if sys.platform.startswith("darwin"):
+            codesign_cmd = "codesign --force --sign lldb_codesign %s" % (binary_path)
+            call(codesign_cmd, shell=True)
+
     def findBuiltClang(self):
         """Tries to find and use Clang from the build directory as the compiler (instead of the system compiler)."""
         paths_to_try = [
           "llvm-build/Release+Asserts/x86_64/Release+Asserts/bin/clang",
           "llvm-build/Debug+Asserts/x86_64/Debug+Asserts/bin/clang",
           "llvm-build/Release/x86_64/Release/bin/clang",
           "llvm-build/Debug/x86_64/Debug/bin/clang",
         ]