W3C test importer: skip ref test if ref file not found.

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 237 matching lines @@
                 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
 
                 if 'reference' in test_info.keys():
                     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.
+                    # directly rather than relying on a naming convention.
                     # Using a naming convention creates duplicate copies of the
-                    # reference files.
+                    # reference files (http://crrev.com/268729).
                     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 not self.filesystem.exists(test_info['reference']):
+                        _log.warning('%s skipped because ref file %s was not found.',
+                                     path_full, ref_file)
+                        continue

[qyearsley, 2016/11/12 00:16:33]

This part is the actual main change for this CL.

+
                     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
 
                     reftests += 1
                     total_tests += 1
                     copy_list.append({'src': test_info['reference'], 'dest': ref_file,
                                       'reference_support_info': test_info['reference_support_info']})
@@ skipping 61 matching lines @@
             for file_to_copy in dir_to_copy['copy_list']:
                 # FIXME: Split this block into a separate function.
                 orig_filepath = self.filesystem.normpath(file_to_copy['src'])
 
                 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)
+                    _log.error('%s not found. Possible error in the test.', orig_filepath)

[qyearsley, 2016/11/12 00:16:33]

In theory I think we might not hit this condition any more after this change.

                     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))
 
                 relpath = self.filesystem.relpath(new_filepath, self.layout_tests_dir)
                 if not self.options.overwrite and self.filesystem.exists(new_filepath):
                     _log.info('  skipping %s', relpath)
                 else:
                     # FIXME: Maybe doing a file diff is in order here for existing files?
                     # In other words, there's no sense in overwriting identical files, but
                     # there's no harm in copying the identical thing.
                     _log.info('  %s', relpath)
 
                 # Only HTML, XML, or CSS should be converted.
                 # FIXME: Eventually, so should JS when support is added for this type of conversion.
                 mimetype = mimetypes.guess_type(orig_filepath)
                 if 'is_jstest' not in file_to_copy and (
                         'html' in str(mimetype[0]) or 'xml' in str(mimetype[0]) or 'css' in str(mimetype[0])):
-                    converted_file = convert_for_webkit(new_path, filename=orig_filepath,
-                                                        reference_support_info=reference_support_info)
+                    converted_file = convert_for_webkit(
+                        new_path, filename=orig_filepath,
+                        reference_support_info=reference_support_info,
+                        host=self.host)

[qyearsley, 2016/11/12 00:16:33]

This change makes it so that the MockFileSystem is used in tests for
convert_for_webkit.

 
                     if not converted_file:
                         if not self.import_in_place and not self.options.dry_run:
                             self.filesystem.copyfile(orig_filepath, new_filepath)  # The file was unmodified.
                     else:
                         for prefixed_property in converted_file[0]:
                             total_prefixed_properties.setdefault(prefixed_property, 0)
                             total_prefixed_properties[prefixed_property] += 1
 
                         prefixed_properties.extend(set(converted_file[0]) - set(prefixed_properties))
                         if not self.options.dry_run:
-                            outfile = open(new_filepath, 'wb')
-                            outfile.write(converted_file[1].encode('utf-8'))
-                            outfile.close()
+                            self.filesystem.write_text_file(new_filepath, converted_file[1])

[qyearsley, 2016/11/12 00:16:33]

This change makes it so that the MockFileSystem is used in tests.

                 else:
                     if not self.import_in_place and not self.options.dry_run:
                         self.filesystem.copyfile(orig_filepath, new_filepath)
                         if self.filesystem.read_binary_file(orig_filepath)[:2] == '#!':
                             self.filesystem.make_executable(new_filepath)
 
                 copied_files.append(new_filepath.replace(self._webkit_root, ''))
 
         _log.info('')
         _log.info('Import complete')
@@ skipping 13 matching lines @@
         """Checks whether a source path is too long to import.
 
         Args:
             Absolute path of file to be imported.
 
         Returns:
             True if the path is too long to import, False if it's OK.
         """
         path_from_repo_base = os.path.relpath(source_path, self.source_repo_path)
         return len(path_from_repo_base) > MAX_PATH_LENGTH