Pulling in latest software construction toolkit.

site_scons/site_tools/component_builders.py

 #!/usr/bin/python2.4
 # Copyright 2008, 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:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
@@ skipping 101 matching lines @@
   Returns:
     A modified clone of the environment.
   """
   # Clone environment so we can modify it
   env = env.Clone()
 
   # Add all keyword arguments to the environment
   for k, v in kwargs.items():
     env[k] = v
 
+  # Add compiler flags for included headers, if any
+  env['INCLUDES'] = env.Flatten(env.subst_list(['$INCLUDES']))
+  for h in env['INCLUDES']:
+    env.Append(CCFLAGS = ['${CCFLAG_INCLUDE}%s' % h])
+
   # Call platform-specific component setup function, if any
   if env.get('COMPONENT_PLATFORM_SETUP'):
     env['COMPONENT_PLATFORM_SETUP'](env, builder_name)
 
   # Return the modified environment
   return env
 
 #------------------------------------------------------------------------------
 
 # TODO(rspangler): Should be possible to refactor programs, test programs,
 # libs to all publish as packages, for simplicity and code reuse.
 
 
 def ComponentPackageDeferred(env):
   """Deferred build steps for component package.
 
   Args:
     env: Environment from ComponentPackage().
 
   Sets up the aliases to build the package.
   """
   package_name = env['PACKAGE_NAME']
 
   # Install program and resources
   all_outputs = []
-  components = _RetrieveComponents(package_name,
-                                   env.get('COMPONENT_PACKAGE_FILTER'))
+  filter = env.Flatten(env.subst_list('$COMPONENT_PACKAGE_FILTER'))
+  components = _RetrieveComponents(package_name, filter)
   for resource, dest_dir in env.get('COMPONENT_PACKAGE_RESOURCES').items():
     all_outputs += env.ReplicatePublished(dest_dir, components, resource)
 
   # Add installed program and resources to the alias
   env.Alias(package_name, all_outputs)
 
 
 def ComponentPackage(self, package_name, dest_dir, **kwargs):
   """Pseudo-builder for package containing other components.
 
@@ skipping 44 matching lines @@
     Passthrough return code from env.StaticLibrary() or env.SharedLibrary().
 
   TODO(rspangler): Perhaps this should be a generator builder, so it can take
   a list of inputs and return a list of outputs?
   """
   # Clone and modify environment
   env = _ComponentPlatformSetup(self, 'ComponentObject', **kwargs)
 
   # Make appropriate object type
   if env.get('COMPONENT_STATIC'):
-    return env.StaticObject(*args, **kwargs)
+    o = env.StaticObject(*args, **kwargs)
   else:
-    return env.SharedObject(*args, **kwargs)
+    o = env.SharedObject(*args, **kwargs)
+
+  # Add dependencies on includes
+  env.Depends(o, env['INCLUDES'])
+
+  return o
 
 #------------------------------------------------------------------------------
 
 
 def ComponentLibrary(self, lib_name, *args, **kwargs):
   """Pseudo-builder for library to handle platform-dependent type.
 
   Args:
     self: Environment in which we were called.
     lib_name: Library name.
     args: Positional arguments.
     kwargs: Keyword arguments.
 
   Returns:
     Passthrough return code from env.StaticLibrary() or env.SharedLibrary().
   """
   # Clone and modify environment
   env = _ComponentPlatformSetup(self, 'ComponentLibrary', **kwargs)
 
   # Make appropriate library type
   if env.get('COMPONENT_STATIC'):
     lib_outputs = env.StaticLibrary(lib_name, *args, **kwargs)
   else:
     lib_outputs = env.SharedLibrary(lib_name, *args, **kwargs)
 
+  # Add dependencies on includes
+  env.Depends(lib_outputs, env['INCLUDES'])
+
   # Scan library outputs for files we need to link against this library, and
   # files we need to run executables linked against this library.
   need_for_link = []
   need_for_debug = []
   need_for_run = []
   for o in lib_outputs:
     if o.suffix in env['COMPONENT_LIBRARY_LINK_SUFFIXES']:
       need_for_link.append(o)
     if o.suffix in env['COMPONENT_LIBRARY_DEBUG_SUFFIXES']:
       need_for_debug.append(o)
@@ skipping 49 matching lines @@
 
   # Add an alias for running the test in the test directory, if there's a test
   # command line.
   if env.get('COMPONENT_TEST_CMDLINE'):
     # Test program is the first run resource we replicated.
     test_program = env.ReplicatePublished('$TESTS_DIR', prog_name, 'run')
     env.Replace(
         COMMAND_OUTPUT_CMDLINE=env['COMPONENT_TEST_CMDLINE'],
         COMMAND_OUTPUT_RUN_DIR='$TESTS_DIR',
     )
-    test_out = env.CommandOutput(
-        '$TEST_OUTPUT_DIR/${PROGRAM_BASENAME}.out.txt', test_program)
+    test_out_name = '$TEST_OUTPUT_DIR/${PROGRAM_BASENAME}.out.txt'
+    if (env.GetOption('component_test_retest')
+        and env.File(test_out_name).exists()):
+      # Delete old test results, so test will rerun.
+      env.Execute(SCons.Script.Delete(test_out_name))
+
+    # Set timeout based on test size
+    timeout = env.get('COMPONENT_TEST_TIMEOUT')
+    if type(timeout) is dict:
+      timeout = timeout.get(env.get('COMPONENT_TEST_SIZE'))
+    if timeout:
+      env['COMMAND_OUTPUT_TIMEOUT'] = timeout
+
+    # Run the test.  Note that we need to refer to the file by name, so that
+    # SCons will recreate the file node after we've deleted it; if we used the
+    # env.File() we created in the if statement above, SCons would still think
+    # it exists and not rerun the test.
+    test_out = env.CommandOutput(test_out_name, test_program)
+
     # Running the test requires the test and its libs copied to the tests dir
     env.Depends(test_out, all_outputs)
     env.ComponentTestOutput('run_' + prog_name, test_out)
 
 
 def ComponentTestProgram(self, prog_name, *args, **kwargs):
   """Pseudo-builder for test program to handle platform-dependent type.
 
   Args:
     self: Environment in which we were called.
     prog_name: Test program name.
     args: Positional arguments.
     kwargs: Keyword arguments.
 
   Returns:
     Output node list from env.Program().
 
   TODO(rspangler): Should have some sort of support for S/M/L categorization
   """
   # Clone and modify environment
   env = _ComponentPlatformSetup(self, 'ComponentTestProgram', **kwargs)
 
   env['PROGRAM_BASENAME'] = prog_name
   env['PROGRAM_NAME'] = '$PROGPREFIX$PROGRAM_BASENAME$PROGSUFFIX'
 
   # Call env.Program()
   out_nodes = env.Program(prog_name, *args, **kwargs)
 
+  # Add dependencies on includes
+  env.Depends(out_nodes, env['INCLUDES'])
+
   # Publish output
   env.Publish(prog_name, 'run', out_nodes[0])
   env.Publish(prog_name, 'debug', out_nodes[1:])
 
   # Add an alias to build the program to the right groups
   a = env.Alias(prog_name, out_nodes)
   for group in env['COMPONENT_TEST_PROGRAM_GROUPS']:
     SCons.Script.Alias(group, a)
 
   # Store list of components for this program
@@ skipping 41 matching lines @@
     Output node list from env.Program().
   """
   # Clone and modify environment
   env = _ComponentPlatformSetup(self, 'ComponentProgram', **kwargs)
 
   env['PROGRAM_BASENAME'] = prog_name
 
   # Call env.Program()
   out_nodes = env.Program(prog_name, *args, **kwargs)
 
+  # Add dependencies on includes
+  env.Depends(out_nodes, env['INCLUDES'])
+
   # Publish output
   env.Publish(prog_name, 'run', out_nodes[0])
   env.Publish(prog_name, 'debug', out_nodes[1:])
 
   # Add an alias to build the program to the right groups
   a = env.Alias(prog_name, out_nodes)
   for group in env['COMPONENT_PROGRAM_GROUPS']:
     SCons.Script.Alias(group, a)
 
   # Store list of components for this program
@@ skipping 13 matching lines @@
 
   Args:
     self: Environment in which we were called.
     test_name: Test name.
     nodes: List of files/Nodes output by the test.
 
   Returns:
     Passthrough return code from env.Alias().
   """
 
-  # Add an alias for the test outputs, and add it to the right groups
+  # Add an alias for the test output
   a = self.Alias(test_name, nodes)
-  for group in self['COMPONENT_TEST_OUTPUT_GROUPS']:
+
+  groups = self.get('COMPONENT_TEST_OUTPUT_GROUPS')
+  if not groups:
+    # Output group not explicitly specified, so automatically add to groups
+    if self.get('COMPONENT_TEST_ENABLED'):
+      # Enabled tests go in all tests, and their size category
+      groups = ['run_all_tests']
+      if self.get('COMPONENT_TEST_SIZE'):
+        groups.append(self.subst('run_${COMPONENT_TEST_SIZE}_tests'))
+    else:
+      # Disabled tests only go in their group
+      groups = ['run_disabled_tests']
+
+  for group in groups:
     SCons.Script.Alias(group, a)
 
   # Return the output node
   return a
 
 #------------------------------------------------------------------------------
 
 
 def generate(env):
   # NOTE: SCons requires the use of this name, which fails gpylint.
   """SCons entry point for this tool."""
 
   env.Replace(
       COMPONENT_LIBRARY_DIR='$TARGET_ROOT/lib',
       STAGING_DIR='$TARGET_ROOT/staging',
       TESTS_DIR='$TARGET_ROOT/tests',
       TEST_OUTPUT_DIR='$TARGET_ROOT/test_output',
       # Default command line for a test is just the name of the file.
       # TODO(rspangler): Why doesn't the following work:
       # COMPONENT_TEST_CMDLINE='${SOURCE.abspath}',
       # (it generates a SCons error)
       COMPONENT_TEST_CMDLINE='${PROGRAM_NAME}',
-      COMPONENT_STATIC=True,  # Static linking is a sensible default.
+      # Default test size is large
+      COMPONENT_TEST_SIZE='large',
+      # Default timeouts for component tests
+      COMPONENT_TEST_TIMEOUT={'large':900, 'medium':450, 'small':180},
+      # Tests are enabled by default
+      COMPONENT_TEST_ENABLED=True,
+      # Static linking is a sensible default
+      COMPONENT_STATIC=True,
       # Don't publish libraries to the staging dir by themselves by default.
       COMPONENT_LIBRARY_PUBLISH=False,
   )
   env.Append(
       LIBPATH=['$COMPONENT_LIBRARY_DIR'],
       RPATH=['$COMPONENT_LIBRARY_DIR'],
 
       # Default alias groups for component builders
       COMPONENT_PACKAGE_GROUPS=['all_packages'],
       COMPONENT_LIBRARY_GROUPS=['all_libraries'],
       COMPONENT_PROGRAM_GROUPS=['all_programs'],
       COMPONENT_TEST_PROGRAM_GROUPS=['all_test_programs'],
-      COMPONENT_TEST_OUTPUT_GROUPS=['run_all_tests'],
 
       # Additional components whose resources should be copied into program
       # directories, in addition to those from LIBS and the program itself.
       LIBS=[],
       COMPONENTS=[],
 
       # Dicts of what resources should go in each destination directory for
       # programs and test programs.
       COMPONENT_PACKAGE_RESOURCES={
           'run': '$PACKAGE_DIR',
           'debug': '$PACKAGE_DIR',
       },
       COMPONENT_PROGRAM_RESOURCES={
           'run': '$STAGING_DIR',
           'debug': '$STAGING_DIR',
       },
       COMPONENT_TEST_RESOURCES={
           'run': '$TESTS_DIR',
           'debug': '$TESTS_DIR',
           'test_input': '$TESTS_DIR',
       },
   )
 
+  # Add command line option for retest
+  SCons.Script.AddOption(
+      '--retest',
+      dest='component_test_retest',
+      action='store_true',
+      help='force all tests to rerun')
+  SCons.Script.Help('  --retest                    '
+                    'Rerun specified tests, ignoring cached results.\n')
+
   # Add our pseudo-builder methods
   env.AddMethod(_InitializeComponentBuilders)
   env.AddMethod(_StoreComponents)
   env.AddMethod(ComponentPackage)
   env.AddMethod(ComponentObject)
   env.AddMethod(ComponentLibrary)
   env.AddMethod(ComponentProgram)
   env.AddMethod(ComponentTestProgram)
   env.AddMethod(ComponentTestOutput)
 
   # Add our target groups
   AddTargetGroup('all_libraries', 'libraries can be built')
   AddTargetGroup('all_programs', 'programs can be built')
   AddTargetGroup('all_test_programs', 'tests can be built')
   AddTargetGroup('all_packages', 'packages can be built')
   AddTargetGroup('run_all_tests', 'tests can be run')
+  AddTargetGroup('run_disabled_tests', 'tests are disabled')
+  AddTargetGroup('run_small_tests', 'small tests can be run')
+  AddTargetGroup('run_medium_tests', 'medium tests can be run')
+  AddTargetGroup('run_large_tests', 'large tests can be run')
+