NOT FOR LANDING: How do we add unit tests for bindings?

third_party/WebKit/Tools/Scripts/webkitpy/bindings/bindings_tests.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.
 #
 # THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 # PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 # OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
+
 from contextlib import contextmanager
 import filecmp
 import fnmatch
 import os
 import shutil
 import sys
 import tempfile
 
 from webkitpy.common.system.executive import Executive
 
-# Source/ path is needed both to find input IDL files, and to import other
-# Python modules.
-module_path = os.path.dirname(__file__)
-source_path = os.path.normpath(os.path.join(module_path, os.pardir, os.pardir,
-                                            os.pardir, os.pardir, 'Source'))
-bindings_script_path = os.path.join(source_path, 'bindings', 'scripts')
-sys.path.append(bindings_script_path)  # for Source/bindings imports
+from webkitpy.bindings import bindings_path_finder
+sys.path.append(bindings_path_finder.get_bindings_scripts())
 
 from code_generator_v8 import CodeGeneratorDictionaryImpl
 from code_generator_v8 import CodeGeneratorV8
 from code_generator_v8 import CodeGeneratorUnionType
 from code_generator_v8 import CodeGeneratorCallbackFunction
 from code_generator_web_module import CodeGeneratorWebModule
 from compute_interfaces_info_individual import InterfaceInfoCollector
 from compute_interfaces_info_overall import (compute_interfaces_info_overall,
                                              interfaces_info)
 from idl_compiler import (generate_bindings,
@@ skipping 29 matching lines @@
     'TestInterface2Partial2.idl',
 ])
 
 # core/inspector/InspectorInstrumentation.idl is not a valid Blink IDL.
 NON_BLINK_IDL_FILES = frozenset([
     'InspectorInstrumentation.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')
+SOURCE_PATH = bindings_path_finder.get_blink_source()
+
+TEST_INPUT_DIRECTORY = bindings_path_finder.get_test_input()
+REFERENCE_DIRECTORY = bindings_path_finder.get_test_results()
 
 # component -> ComponentInfoProvider.
 # Note that this dict contains information about testing idl files, which live
 # in Source/bindings/tests/idls/{core,modules}, not in Source/{core,modules}.
 component_info_providers = {}
 
 
 @contextmanager
 def TemporaryDirectory():
     """Wrapper for tempfile.mkdtemp() so it's usable with 'with' statement.
@@ skipping 17 matching lines @@
         idl_paths = []
         for dirpath, _, files in os.walk(directory):
             idl_paths.extend(os.path.join(dirpath, filename)
                              for filename in fnmatch.filter(files, '*.idl'))
         return idl_paths
 
     def collect_blink_idl_paths():
         """Returns IDL file paths which blink actually uses."""
         idl_paths = []
         for component in COMPONENT_DIRECTORY:
-            directory = os.path.join(source_path, component)
+            directory = os.path.join(SOURCE_PATH, component)
             idl_paths.extend(idl_paths_recursive(directory))
         return idl_paths
 
     def collect_interfaces_info(idl_path_list):
         info_collector = InterfaceInfoCollector()
         for idl_path in idl_path_list:
             if os.path.basename(idl_path) in NON_BLINK_IDL_FILES:
                 continue
             info_collector.collect_info(idl_path)
         info = info_collector.get_info_as_dict()
@@ skipping 17 matching lines @@
     # from Node, we also need to know that these inherit from EventTarget,
     # since this is also special-cased and Node inherits from EventTarget,
     # but this inheritance information requires computing dependencies for
     # the real Node.idl file.
     non_test_idl_paths = collect_blink_idl_paths()
     # For bindings test IDL files, we collect interfaces info for each
     # component so that we can generate union type containers separately.
     test_idl_paths = {}
     for component in COMPONENT_DIRECTORY:
         test_idl_paths[component] = idl_paths_recursive(
-            os.path.join(test_input_directory, component))
+            os.path.join(TEST_INPUT_DIRECTORY, component))
     # 2nd-stage computation: individual, then overall
     #
     # Properly should compute separately by component (currently test
     # includes are invalid), but that's brittle (would need to update this file
     # for each new component) and doesn't test the code generator any better
     # than using a single component.
     non_test_interfaces_info, non_test_component_info = collect_interfaces_info(non_test_idl_paths)
     test_interfaces_info = {}
     test_component_info = {}
     for component, paths in test_idl_paths.iteritems():
@@ skipping 72 matching lines @@
             # 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(output_files):
-        reference_files = [os.path.join(reference_directory,
+        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 zip(reference_files, output_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)
+        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:
@@ skipping 16 matching lines @@
                     os.makedirs(partial_interface_output_dir)
                 partial_interface_options = IdlCompilerOptions(
                     output_directory=partial_interface_output_dir,
                     impl_output_directory=None,
                     cache_directory=None,
                     target_component='modules')
 
             idl_filenames = []
             dictionary_impl_filenames = []
             partial_interface_filenames = []
-            input_directory = os.path.join(test_input_directory, component)
+            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_path = os.path.realpath(
                         os.path.join(input_directory, filename))
                     idl_filenames.append(idl_path)
                     idl_basename = os.path.basename(idl_path)
                     definition_name, _ = os.path.splitext(idl_basename)
@@ skipping 49 matching lines @@
     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)
+        return bindings_tests(REFERENCE_DIRECTORY, verbose)
     with TemporaryDirectory() as temp_dir:
         return bindings_tests(temp_dir, verbose)