Added core and modules to binding tests results for binding modularization.

Tools/Scripts/webkitpy/bindings/main.py

 # Copyright (C) 2011 Google Inc.  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 copyright
 #    notice, this list of conditions and the following disclaimer in the
 #    documentation and/or other materials provided with the distribution.
@@ skipping 54 matching lines @@
     'TestPartialInterface.idl',
     'TestPartialInterface2.idl',
     'TestPartialInterface3.idl',
 ])
 
 COMPONENT_DIRECTORY = frozenset(['core', 'modules'])
 
 test_input_directory = os.path.join(source_path, 'bindings', 'tests', 'idls')
 reference_directory = os.path.join(source_path, 'bindings', 'tests', 'results')
 
+PLY_LEX_YACC_FILES = frozenset([
+    'lextab.py',  # PLY lex
+    'lextab.pyc',
+    'parsetab.pickle',  # PLY yacc
+])
 
 @contextmanager
 def TemporaryDirectory():
     """Wrapper for tempfile.mkdtemp() so it's usable with 'with' statement.
 
     Simple backport of tempfile.TemporaryDirectory from Python 3.2.
     """
     name = tempfile.mkdtemp()
     try:
         yield name
@@ skipping 33 matching lines @@
     # than using a single component.
     for idl_filename in idl_paths_recursive(source_path):
         compute_info_individual(idl_filename, 'tests')
     info_individuals = [info_individual()]
     compute_interfaces_info_overall(info_individuals)
 
 
 def bindings_tests(output_directory, verbose):
     executive = Executive()
 
+    def list_files(directory):
+        files = []
+        for component in os.listdir(directory):
+            if component not in COMPONENT_DIRECTORY:
+                continue
+            directory_with_component = os.path.join(directory, component)
+            for filename in os.listdir(directory_with_component):
+                files.append(os.path.join(directory_with_component, filename))
+        return files
+
     def diff(filename1, filename2):
         # Python's difflib module is too slow, especially on long output, so
         # run external diff(1) command
         cmd = ['diff',
                '-u',  # unified format
                '-N',  # treat absent files as empty
                filename1,
                filename2]
         # Return output and don't raise exception, even though diff(1) has
         # non-zero exit if files differ.
         return executive.run_command(cmd, error_handler=lambda x: None)
 
+    def is_cache_file(filename):
+        if filename in PLY_LEX_YACC_FILES:
+            return True
+        if filename.endswith('.cache'):  # Jinja
+            return True
+        return False
+
     def delete_cache_files():
         # FIXME: Instead of deleting cache files, don't generate them.
-        cache_files = [os.path.join(output_directory, output_file)
-                       for output_file in os.listdir(output_directory)
-                       if (output_file in ('lextab.py',  # PLY lex
-                                           'lextab.pyc',
-                                           'parsetab.pickle') or  # PLY yacc
-                           output_file.endswith('.cache'))]  # Jinja
+        cache_files = [path for path in list_files(output_directory)
+                       if is_cache_file(os.path.basename(path))]
         for cache_file in cache_files:
             os.remove(cache_file)
 
     def identical_file(reference_filename, output_filename):
         reference_basename = os.path.basename(reference_filename)
 
         if not os.path.isfile(reference_filename):
             print 'Missing reference file!'
             print '(if adding new test, update reference files)'
             print reference_basename
             print
             return False
 
         if not filecmp.cmp(reference_filename, output_filename):
             # cmp is much faster than diff, and usual case is "no differance",
             # so only run diff if cmp detects a difference
             print 'FAIL: %s' % reference_basename
             print diff(reference_filename, output_filename)
             return False
 
         if verbose:
             print 'PASS: %s' % reference_basename
         return True
 
-    def identical_output_files():
-        file_pairs = [(os.path.join(reference_directory, output_file),
-                       os.path.join(output_directory, output_file))
-                      for output_file in os.listdir(output_directory)]
+    def identical_output_files(output_files):
+        reference_files = [os.path.join(reference_directory,
+                                        os.path.relpath(path, output_directory))
+                           for path in output_files]
         return all([identical_file(reference_filename, output_filename)
-                    for (reference_filename, output_filename) in file_pairs])
+                    for (reference_filename, output_filename) in zip(reference_files, output_files)])
 
-    def no_excess_files():
-        generated_files = set(os.listdir(output_directory))
-        generated_files.add('.svn')  # Subversion working copy directory
-        excess_files = [output_file
-                        for output_file in os.listdir(reference_directory)
-                        if output_file not in generated_files]
+    def no_excess_files(output_files):
+        generated_files = set([os.path.relpath(path, output_directory)
+                               for path in output_files])
+        # Add subversion working copy directories in core and modules.
+        for component in COMPONENT_DIRECTORY:
+            generated_files.add(os.path.join(component, '.svn'))
+
+        excess_files = []
+        for path in list_files(reference_directory):
+            relpath = os.path.relpath(path, reference_directory)
+            if relpath not in generated_files:
+                excess_files.append(relpath)
         if excess_files:
             print ('Excess reference files! '
                   '(probably cruft from renaming or deleting):\n' +
                   '\n'.join(excess_files))
             return False
         return True
 
     try:
         generate_interface_dependencies()
-        idl_compiler = IdlCompilerV8(output_directory,
-                                     interfaces_info=interfaces_info,
-                                     only_if_changed=True)
-        dictionary_impl_compiler = IdlCompilerDictionaryImpl(
-            output_directory, interfaces_info=interfaces_info,
-            only_if_changed=True)
+        for component in COMPONENT_DIRECTORY:
+            output_dir = os.path.join(output_directory, component)
+            if not os.path.exists(output_dir):
+                os.makedirs(output_dir)
 
-        idl_filenames = []
-        for component in COMPONENT_DIRECTORY:
+            idl_compiler = IdlCompilerV8(output_dir,
+                                         interfaces_info=interfaces_info,
+                                         only_if_changed=True)
+            dictionary_impl_compiler = IdlCompilerDictionaryImpl(
+                output_dir, interfaces_info=interfaces_info,
+                only_if_changed=True)
+
+            idl_filenames = []
             input_directory = os.path.join(test_input_directory, component)
             for filename in os.listdir(input_directory):
                 if (filename.endswith('.idl') and
                     # Dependencies aren't built
                     # (they are used by the dependent)
                     filename not in DEPENDENCY_IDL_FILES):
                     idl_filenames.append(
                         os.path.realpath(
                             os.path.join(input_directory, filename)))
-        for idl_path in idl_filenames:
-            idl_basename = os.path.basename(idl_path)
-            idl_compiler.compile_file(idl_path)
-            definition_name, _ = os.path.splitext(idl_basename)
-            if (definition_name in interfaces_info and
-                interfaces_info[definition_name]['is_dictionary']):
-                dictionary_impl_compiler.compile_file(idl_path)
-            if verbose:
-                print 'Compiled: %s' % idl_path
+            for idl_path in idl_filenames:
+                idl_basename = os.path.basename(idl_path)
+                idl_compiler.compile_file(idl_path)
+                definition_name, _ = os.path.splitext(idl_basename)
+                if (definition_name in interfaces_info and interfaces_info[definition_name]['is_dictionary']):
+                    dictionary_impl_compiler.compile_file(idl_path)
+                if verbose:
+                    print 'Compiled: %s' % idl_path
     finally:
         delete_cache_files()
 
     # Detect all changes
-    passed = identical_output_files()
-    passed &= no_excess_files()
+    output_files = list_files(output_directory)
+    passed = identical_output_files(output_files)
+    passed &= no_excess_files(output_files)
 
     if passed:
         if verbose:
             print
             print PASS_MESSAGE
         return 0
     print
     print FAIL_MESSAGE
     return 1
 
 
 def run_bindings_tests(reset_results, verbose):
     # Generate output into the reference directory if resetting results, or
     # a temp directory if not.
     if reset_results:
         print 'Resetting results'
         return bindings_tests(reference_directory, verbose)
     with TemporaryDirectory() as temp_dir:
         return bindings_tests(temp_dir, verbose)