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.
 
@@ skipping 15 matching lines @@
     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())
     # 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)
     os.mkdir(self.LongTempDir)
+    # Create a directory whose path will be exactly 235 chars long

[Karl, 2015/02/20 16:30:43]

Should there be a check to verify that the path isn't greater than 235?

[jvoung (off chromium), 2015/02/23 22:12:00]

Added an assert that it's exactly 235 (if that's what you meant).

I guess this really shouldn't have regressed:
https://code.google.com/p/nativeclient/issues/detail?id=4098

But I haven't had time to fully investigate the windows build (make -j1 !). I
know upstream has some changes to add support for extended path lengths which
may have affected this. On the other hand, spaces in paths were only fixed
recently, and longish files w/ spaces is supported (just 235 + x instead of 240
+ x)...

[Karl, 2015/02/23 22:18:18]

Actually, what I meant (both here and with path test on 240 above), what happens
if cwd_len is greater than 235? In such cases, does the following instruction
make sense?

[jvoung (off chromium), 2015/02/23 22:41:22]

I see, I added another check for cwd's len.

+    shorter_dir_len = 235 - cwd_len - 1
+    self.ShorterTempDir = os.path.join(self.cwd_backup, 'a' * shorter_dir_len)
+    os.mkdir(self.ShorterTempDir)
 
   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)