W3C test importer: Skip importing files whose ref files would be too long.

third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer.py

 # Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 #
 # 1. Redistributions of source code must retain the above
 #    copyright notice, this list of conditions and the following
 #    disclaimer.
 # 2. Redistributions in binary form must reproduce the above
@@ skipping 227 matching lines @@
 
                 if self.filesystem.basename(root) in DIRS_TO_INCLUDE:
                     copy_list.append({'src': fullpath, 'dest': filename})
                     continue
 
                 test_parser = TestParser(vars(self.options), filename=fullpath)
                 test_info = test_parser.analyze_test()
                 if test_info is None:
                     continue
 
+                if self.path_too_long(path_full):
+                    _log.warning('%s skipped due to long path. '
+                                 'Max length from repo base %d chars; see http://crbug.com/609871.',
+                                 path_full, MAX_PATH_LENGTH)
+                    continue

[qyearsley, 2016/05/20 21:09:46]

The skipping has been moved from import_tests to find_importable_tests.

+
                 if 'reference' in test_info.keys():
-                    reftests += 1
-                    total_tests += 1
                     test_basename = self.filesystem.basename(test_info['test'])
-
                     # Add the ref file, following WebKit style.
                     # FIXME: Ideally we'd support reading the metadata
                     # directly rather than relying  on a naming convention.
                     # Using a naming convention creates duplicate copies of the
                     # reference files.
                     ref_file = self.filesystem.splitext(test_basename)[0] + '-expected'
                     # Make sure to use the extension from the *reference*, not
                     # from the test, because at least flexbox tests use XHTML
                     # references but HTML tests.
                     ref_file += self.filesystem.splitext(test_info['reference'])[1]
 
+                    if self.path_too_long(path_full.replace(filename, ref_file)):
+                        _log.warning('%s skipped because path of ref file %s would be too long. '
+                                     'Max length from repo base %d chars; see http://crbug.com/609871.',
+                                     path_full, ref_file, MAX_PATH_LENGTH)
+                        continue

[qyearsley, 2016/05/20 21:09:46]

This should skip importing in the case where the path of the file is not too
long, but the reference file would be too long.

 path_full is the absolute path to the test file
 filename is the basename (without directory) of the test file
 ref_file is the basename (without directory) of the reference file (which my
have a different extension than the test file).

This could hopefully be made simpler to understand if (1) the functions here
were made shorter and (2) the variable names were improved. I'd like to do that
in follow-up CLs.

+
+                    reftests += 1
+                    total_tests += 1
                     copy_list.append({'src': test_info['reference'], 'dest': ref_file,
                                       'reference_support_info': test_info['reference_support_info']})
                     copy_list.append({'src': test_info['test'], 'dest': filename})
 
                 elif 'jstest' in test_info.keys():
                     jstests += 1
                     total_tests += 1
                     copy_list.append({'src': fullpath, 'dest': filename})
                 else:
                     total_tests += 1
@@ skipping 54 matching lines @@
 
                 if self.filesystem.isdir(orig_filepath):
                     # FIXME: Figure out what is triggering this and what to do about it.
                     _log.error('%s refers to a directory' % orig_filepath)
                     continue
 
                 if not self.filesystem.exists(orig_filepath):
                     _log.warning('%s not found. Possible error in the test.', orig_filepath)
                     continue
 
-                if self.path_too_long(orig_filepath):
-                    _log.warning('%s skipped (longer than %d chars), to avoid hitting Windows max path length on builders (http://crbug.com/609871).',
-                                 orig_filepath, MAX_PATH_LENGTH)
-                    continue
-
                 new_filepath = self.filesystem.join(new_path, file_to_copy['dest'])
                 if 'reference_support_info' in file_to_copy.keys() and file_to_copy['reference_support_info'] != {}:
                     reference_support_info = file_to_copy['reference_support_info']
                 else:
                     reference_support_info = None
 
                 if not self.filesystem.exists(self.filesystem.dirname(new_filepath)):
                     if not self.import_in_place and not self.options.dry_run:
                         self.filesystem.maybe_make_directory(self.filesystem.dirname(new_filepath))
 
@@ skipping 59 matching lines @@
         """ Creates a destination directory that mirrors that of the source directory """
 
         new_subpath = self.dir_to_import[len(self.top_of_repo):]
 
         destination_directory = self.filesystem.join(self.destination_directory, new_subpath)
 
         if not self.filesystem.exists(destination_directory):
             self.filesystem.maybe_make_directory(destination_directory)
 
         _log.info('Tests will be imported into: %s', destination_directory)