Update PNaCl to LLVM/Clang/Libcxx 223109 (nacl-change)

pnacl/driver/tests/path_length_test.py

 #!/usr/bin/python
 # Copyright (c) 2014 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Tests of the pnacl driver.
 
 This tests that we give useful errors when paths are too long, and don't
 unnecessarily generate temp file names that are too long ourselves.
 
 """
 
 import driver_log
 from driver_env import env
 import driver_test_utils
 import driver_tools
 import filetype
 
 import cStringIO
 import os
 import shutil
 import sys
 
 class TestPathNames(driver_test_utils.DriverTesterCommon):
   def setUp(self):
     super(TestPathNames, self).setUp()
     driver_test_utils.ApplyTestEnvOverrides(env)
     self.backup_exit = sys.exit
     sys.exit = driver_test_utils.FakeExit
-    cwd_len = len(os.getcwd())
+    self.cwd_backup = os.getcwd()
+    cwd_len = len(self.cwd_backup)
+    # Create a directory whose path will be exactly 235 chars long
+    assert(cwd_len < 235)
+    shorter_dir_len = 235 - cwd_len - 1
+    self.ShorterTempDir = os.path.join(self.cwd_backup, 'a' * shorter_dir_len)
+    assert(235 == len(self.ShorterTempDir),
+           "ShorterTempDir isn't 235 chars: %d" % len(self.ShorterTempDir))
+    os.mkdir(self.ShorterTempDir)
     # Create a directory whose path will be exactly 240 chars long
     dir_len = 240 - cwd_len - 1
-    self.cwd_backup = os.getcwd()
     self.LongTempDir = os.path.join(self.cwd_backup, 'a' * dir_len)
+    assert(240 == len(self.LongTempDir),
+           "LongTempDir isn't 240 chars: %d" % len(self.LongTempDir))
     os.mkdir(self.LongTempDir)
 
   def tearDown(self):
     super(TestPathNames, self).tearDown()
     os.chdir(self.cwd_backup)
     sys.exit = self.backup_exit
     shutil.rmtree(self.LongTempDir)
+    shutil.rmtree(self.ShorterTempDir)
 
   def WriteCFile(self, filename):
     with open(filename, 'w') as f:
       f.write('int main() { return 0; }')
 
   def AssertRaisesAndReturnOutput(self, exc, func, *args):
     capture_out = cStringIO.StringIO()
     driver_log.Log.CaptureToStream(capture_out)
     self.assertRaises(exc, func, *args)
     driver_log.Log.ResetStreams()
     return capture_out.getvalue()
 
   def test_PathWithSpaces(self):
     '''Test that the driver correctly handles paths containing spaces'''
     if not driver_test_utils.CanRunHost():
       return
 
-    name = os.path.join(self.LongTempDir, 'a file')
+    name = os.path.join(self.ShorterTempDir, 'a file')
     self.WriteCFile(name + '.c')
     driver_tools.RunDriver('pnacl-clang',
                            [name + '.c', '-c', '-o', name + '.o'])
     self.assertEqual('po', filetype.FileType(name + '.o'))
 
   def test_InputPathTooLong(self):
     '''Test that clang and ld reject input paths that are too long
 
      Test that compiling and linking paths shorter than 255 succeeds and paths
      longer than 255 fails.
@@ skipping 109 matching lines @@
     longname = os.path.join(longerdir, 'a' * 3)
     os.rename(shortname + '.o', longname + '.o')
 
     output = self.AssertRaisesAndReturnOutput(
         driver_test_utils.DriverExitException,
         driver_tools.RunDriver,
         'pnacl-ld',
         [longname + '.o', '-o', longname])
 
     self.assertIn('.pexe is too long', output)