[test] Key variant flags by variant name everywhere.

tools/run-tests.py

 #!/usr/bin/env python
 #
 # Copyright 2012 the V8 project authors. 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.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 26 matching lines @@
 import platform
 import random
 import shlex
 import subprocess
 import sys
 import time
 
 from testrunner.local import execution
 from testrunner.local import progress
 from testrunner.local import testsuite
-from testrunner.local.testsuite import VARIANT_FLAGS
+from testrunner.local.testsuite import ALL_VARIANTS
 from testrunner.local import utils
 from testrunner.local import verbose
 from testrunner.network import network_execution
 from testrunner.objects import context
 
 
 ARCH_GUESS = utils.DefaultArch()
 DEFAULT_TESTS = [
   "mjsunit",
   "unittests",
@@ skipping 267 matching lines @@
 def BuildbotToV8Mode(config):
   """Convert buildbot build configs to configs understood by the v8 runner.
 
   V8 configs are always lower case and without the additional _x64 suffix for
   64 bit builds on windows with ninja.
   """
   mode = config[:-4] if config.endswith('_x64') else config
   return mode.lower()
 
 def ProcessOptions(options):
-  global VARIANT_FLAGS
+  global ALL_VARIANTS
   global VARIANTS
 
   # Architecture and mode related stuff.
   if options.arch_and_mode:
     options.arch_and_mode = [arch_and_mode.split(".")
         for arch_and_mode in options.arch_and_mode.split(",")]
     options.arch = ",".join([tokens[0] for tokens in options.arch_and_mode])
     options.mode = ",".join([tokens[1] for tokens in options.arch_and_mode])
   options.mode = options.mode.split(",")
   for mode in options.mode:
@@ skipping 70 matching lines @@
     options.slow_tests = "skip"
     options.pass_fail_tests = "skip"
   if options.no_stress:
     VARIANTS = ["default", "nocrankshaft"]
   if options.no_variants:
     VARIANTS = ["default"]
   if options.stress_only:
     VARIANTS = ["stress"]
   if options.variants:
     VARIANTS = options.variants.split(",")
-    if not set(VARIANTS).issubset(VARIANT_FLAGS.keys()):
-      print "All variants must be in %s" % str(VARIANT_FLAGS.keys())
+    if not set(VARIANTS).issubset(ALL_VARIANTS.keys()):
+      print "All variants must be in %s" % str(ALL_VARIANTS.keys())
       return False
   if options.predictable:
     VARIANTS = ["default"]
     options.extra_flags.append("--predictable")
     options.extra_flags.append("--verify_predictable")
     options.extra_flags.append("--no-inline-new")
 
   if not options.shell_dir:
     if options.shell:
       print "Warning: --shell is deprecated, use --shell-dir instead."
@@ skipping 176 matching lines @@
     s.ReadStatusFile(variables)
     s.ReadTestCases(ctx)
     if len(args) > 0:
       s.FilterTestCasesByArgs(args)
     all_tests += s.tests
     s.FilterTestCasesByStatus(options.warn_unused, options.flaky_tests,
                               options.slow_tests, options.pass_fail_tests)
     if options.cat:
       verbose.PrintTestSource(s.tests)
       continue
-    variant_flags = [VARIANT_FLAGS[var] for var in VARIANTS]
-    variant_tests = [ t.CopyAddingFlags(v)
+    variant_flags = s.VariantFlags(VARIANTS)
+    variant_tests = [ t.CopyAddingFlags(flags)
                       for t in s.tests
-                      for v in s.VariantFlags(t, variant_flags) ]
+                      for _, flags in variant_flags(t) ]
 
     if options.random_seed_stress_count > 1:
       # Duplicate test for random seed stress mode.
       def iter_seed_flags():
         for i in range(0, options.random_seed_stress_count):
           # Use given random seed for all runs (set by default in execution.py)
           # or a new random seed if none is specified.
           if options.random_seed:
             yield []
           else:
             yield ["--random-seed=%d" % RandomSeed()]
       s.tests = [
-        t.CopyAddingFlags(v)
+        t.CopyAddingFlags(flags)
         for t in variant_tests
-        for v in iter_seed_flags()
+        for flags in iter_seed_flags()
       ]
     else:
       s.tests = variant_tests
 
     s.tests = ShardTests(s.tests, options.shard_count, options.shard_run)
     num_tests += len(s.tests)
 
   if options.cat:
     return 0  # We're done here.
 
@@ skipping 39 matching lines @@
   exit_code = runner.Run(options.j)
   overall_duration = time.time() - start_time
 
   if options.time:
     verbose.PrintTestDurations(suites, overall_duration)
   return exit_code
 
 
 if __name__ == "__main__":
   sys.exit(Main())