Rename fletch -> dartino

tools/testing/dart/test_options.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test_options_parser;
 
 import "dart:io";
 import "drt_updater.dart";
 import "test_suite.dart";
 import "utils.dart";
 import "compiler_configuration.dart" show CompilerConfiguration;
 import "runtime_configuration.dart" show RuntimeConfiguration;
 
 const List<String> defaultTestSelectors = const [
     'language',
     'corelib',
     'debugger',
     'unsorted',
     'isolate',
     'coroutine',
     'io',
     'ffi',
     'samples',
     'warnings',
-    'fletch_tests',
+    'dartino_tests',
     'cc_tests',
     'lib',
     'os',
     'pkg',
     'typed_data'
 ];
 
 /**
  * Specification of a single test option.
  *
@@ skipping 42 matching lines @@
 
    dart2js: Compile dart code to JavaScript by running dart2js.
          (only valid with the following runtimes: d8, drt, chrome,
          safari, ie9, ie10, ie11, firefox, opera, chromeOnAndroid,
          none (compile only)),
 
    dartanalyzer: Perform static analysis on Dart code by running the analyzer on Java.
    dart2analyzer: Perform static analysis on Dart code by running the analyzer on Dart.
           (only valid with the following runtimes: none)''',
               ['-c', '--compiler'],
-              ['none', 'fletchc'],
+              ['none', 'dartino_compiler'],
               'none'),
           // TODO(antonm): fix the option drt.
           new _TestOptionSpecification(
               'runtime',
               '''Where the tests should be run.
     vm: Run Dart code on the standalone dart vm.
 
     d8: Run JavaScript from the command line using v8.
 
     jsshell: Run JavaScript from the command line using firefox js-shell.
 
     drt: Run Dart or JavaScript in the headless version of Chrome,
          Content shell.
 
     dartium: Run Dart or JavaScript in Dartium.
 
     ContentShellOnAndroid: Run Dart or JavaScript in Dartium content shell
                       on Android.
 
     DartiumOnAndroid: Run Dart or Javascript in Dartium on Android.
 
     [ff | chrome | safari | ie9 | ie10 | ie11 | opera | chromeOnAndroid]:
         Run JavaScript in the specified browser.
 
     none: No runtime, compile only (for example, used for dartanalyzer static
           analysis tests).''',
               ['-r', '--runtime'],
-              ['none', 'fletchc', 'fletchvm', 'fletch_warnings',
-               'fletch_tests', 'fletch_cc_tests'],
-               'fletch_warnings,fletch_tests,fletchc,'
-               'fletch_cc_tests'),
+              ['none', 'dartino_compiler', 'dartinovm', 'dartino_warnings',
+               'dartino_tests', 'dartino_cc_tests'],
+               'dartino_warnings,dartino_tests,dartino_compiler,'
+               'dartino_cc_tests'),
           new _TestOptionSpecification(
               'arch',
               'The architecture to run tests for',
               ['-a', '--arch'],
               ['all', 'ia32', 'x64', 'arm', 'arm64', 'mips',
                'simarm', 'simarm64', 'simmips', 'xarm'],
               'ia32'),
           new _TestOptionSpecification(
               'system',
               'The operating system to run tests on',
@@ skipping 180 matching lines @@
               'build_directory',
               'The name of the build directory, where products are placed.',
               ['--build-directory'],
               [],
               ''),
           new _TestOptionSpecification(
               'noBatch',
               'Do not run tests in batch mode',
               ['-n', '--nobatch'],
               [],
-              true, // Batch-mode breaks fletch_warnings.
+              true, // Batch-mode breaks dartino_warnings.
               type: 'bool'),
           new _TestOptionSpecification(
               'dart2js_batch',
               'Run dart2js tests in batch mode',
               ['--dart2js-batch'],
               [],
               false,
               type: 'bool'),
           new _TestOptionSpecification(
               'append_logs',
@@ skipping 158 matching lines @@
               type: 'int'),
           new _TestOptionSpecification(
               'build_before_testing',
               "Build before running tests.",
               ['--build-before-testing'],
               [],
               1,
               type: 'int'),
           new _TestOptionSpecification(
               'settings_file_name',
-              'The fletch settings file to use for testing',
-              ['--fletch-settings-file'],
+              'The dartino settings file to use for testing',
+              ['--dartino-settings-file'],
               [],
-              '.fletch-settings'),
+              '.dartino-settings'),
           new _TestOptionSpecification(
               'no_java',
               "Don't require running java tests",
               ['--no-java'],
               [],
               false,
               type: 'bool'),
           ];
   }
 
@@ skipping 166 matching lines @@
   }
 
   /**
    * Determine if a particular configuration has a valid combination of compiler
    * and runtime elements.
    */
   bool _isValidConfig(Map config) {
     bool isValid = true;
     List<String> validRuntimes;
     switch (config['compiler']) {
-      case 'fletchc':
-        validRuntimes = const ['none', 'fletchvm'];
+      case 'dartino_compiler':
+        validRuntimes = const ['none', 'dartinovm'];
         break;
       case 'none':
         validRuntimes = const [
-            'fletchc', 'fletch_warnings', 'fletch_tests', 'fletch_cc_tests'];
+            'dartino_compiler', 'dartino_warnings', 'dartino_tests', 'dartino_cc_tests'];
         break;
     }
     if (!validRuntimes.contains(config['runtime'])) {
       isValid = false;
       print("Warning: combination of compiler '${config['compiler']}' and "
           "runtime '${config['runtime']}' is invalid. "
           "Skipping this combination.");
     }
     if ((config['runtime'] == 'ie9' || config['runtime'] == 'ie10') &&
         Platform.operatingSystem != 'windows') {
       isValid = false;
       print("Warning cannot run Internet Explorer on non-Windows operating"
           " system.");
     }
     if (config['shard'] < 1 || config['shard'] > config['shards']) {
       isValid = false;
       print("Error: shard index is ${config['shard']} out of "
             "${config['shards']} shards");
     }
 
     if (config['use_repository_packages'] && config['use_public_packages']) {
       isValid = false;
       print("Cannot have both --use-repository-packages and "
             "--use-public-packages");
     }
 
-    if (config['runtime'] == 'fletchc' && !config['host_checked']) {
+    if (config['runtime'] == 'dartino_compiler' && !config['host_checked']) {
       isValid = false;
       // TODO(ahe): Find a way to make this optional.
-      print("fletch requires --host-checked option.");
+      print("dartino requires --host-checked option.");
     }
 
     if (config['system'] == 'lk' &&
-        (config['compiler'] != 'fletchc' ||
-         config['runtime'] != 'fletchvm')) {
+        (config['compiler'] != 'dartino_compiler' ||
+         config['runtime'] != 'dartinovm')) {
       isValid = false;
       print("Running tests on LK works only in the "
-            "--compiler=fletchc --runtime=fletchvm configuration.");
+            "--compiler=dartino_compiler --runtime=dartinovm configuration.");
     }
 
     return isValid;
   }
 
   /**
    * Recursively expand a configuration with multiple values per key
    * into a list of configurations with exactly one value per key.
    */
   List<Map> _expandConfigurations(Map configuration) {
@@ skipping 202 matching lines @@
         return option;
       }
     }
     print('Unknown test option $name');
     exit(1);
   }
 
 
   List<_TestOptionSpecification> _options;
 }