Make tools/test.dart read standalone.status status file when running tests.

tests/standalone/test_config.dart

 // Copyright (c) 2011, 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("standalone_test_config");
 
 #import("../../tools/testing/dart/test_runner.dart");
+#import("../../tools/testing/dart/status_file_parser.dart");
 
 class StandaloneTestSuite {
-  final String directoryPath = "tests/standalone/src";
+  String directoryPath = "tests/standalone/src";
+  final String statusFilePath = "tests/standalone/standalone.status";
   Function doTest;
   Function doDone;
   String shellPath;
   String pathSeparator;
+  TestSettingMap testSettingMap;
+  Configuration configuration;
 
   StandaloneTestSuite() {
     shellPath = getDartShellFileName() ;
     pathSeparator = new Platform().pathSeparator();
+    testSettingMap = new TestSettingMap();
+    configuration = new Configuration({"mode":"debug",
+                                       "arch":"ia32",
+                                       "checked":"false",
+                                       "component":"vm",
+                                       "system":
+                                           new Platform().operatingSystem()});

[Mads Ager (google), 2011/11/09 14:46:53]

How about avoiding this indentation by doing:

configuration =
    new Configuration({...,
                       ...,
                       ...});

[Bill Hesse, 2011/11/09 14:55:39]

Done.

[Mads Ager (google), 2011/11/09 15:12:35]

Could you upload a new snapshot?

   }
 
   void forEachTest(Function onTest, [Function onDone = null]) {
     doTest = onTest;
     doDone = onDone;
+
+    // Read configuration from status file.
+    List<Section> sections = new List<Section>();
+    ReadConfigurationInto(statusFilePath, sections);
+    for (Section section in sections) {
+      if (configuration.isEnabled(section)) {
+        for (var testSetting in section.testSettings) {
+          testSettingMap.addTest(testSetting, configuration);

[Mads Ager (google), 2011/11/09 14:46:53]

What is a testSetting and why does the testSettingsMap need the configuration?
Since this is unimplemented, maybe leave it out of this change and have a TODO
instead?

[Bill Hesse, 2011/11/09 14:55:39]

This is the immediate next thing to be implemented.  A testSetting, in the most
complex case, is something like:
Process* : PASS, TIMEOUT if $mode == debug
or
isolates/IsolateSpawn : PASS, SKIP if $arch == arm

It has a testName, perhaps with a subdirectory, and perhaps with a wildcard
suffix, and a SetExpression that needs to be evaluated in a environment
(configuration).  Since this is the next step, I stubbed it out to test the
stubbing.

[Mads Ager (google), 2011/11/09 15:12:35]

OK, I would still leave it out of this change until it actually does something.
I don't see much added value at this point and maybe when you start implementing
it you will find that you really want something else in any case.

+        }
+      }
+    }
+
     processDirectory();
   }
 
   void processDirectory() {
+    directoryPath = getDirname(directoryPath);
     Directory dir = new Directory(directoryPath);
-    if (!dir.existsSync()) {
-      dir = new Directory(".." + pathSeparator + directoryPath);
-      Expect.isTrue(dir.existsSync(),
-                    "Cannot find tests/corelib/src or ../tests/corelib/src");
+    Expect.isTrue(dir.existsSync(),
+        "Cannot find tests/standalone/src or ../tests/standalone/src");
       // TODO(ager): Use dir.errorHandler instead when it is implemented.
-    }
     dir.fileHandler = processFile;
     dir.doneHandler = doDone;
     dir.list(false);
   }
 
   void processFile(String filename) {
-    if (filename.endsWith("Test.dart")) {
-      int start = filename.lastIndexOf(pathSeparator);
-      String displayName = filename.substring(start + 1, filename.length - 5);
-      // TODO(whesse): Gather test case info from status file and test file.
-      doTest(new TestCase(displayName,
-                          shellPath,
-                          <String>["--enable_type_checks",
-                                   "--ignore-unrecognized-flags",
-                                   filename ],
-                          completeHandler,
-                          new Set.from([PASS, FAIL, CRASH, TIMEOUT])));
-    }
+    if (!filename.endsWith("Test.dart")) return;
+
+    Expect.isTrue(filename.contains(directoryPath));
+    String testName = filename.substring(

[Mads Ager (google), 2011/11/09 14:46:53]

I linked what you had before much better. This looks complicated. Is there a
reason for the complication here?

[Bill Hesse, 2011/11/09 14:55:39]

The reason for the complication is that some test directories have
subdirectories, and run the tests in those subdirectories as well.  The test
configuration is looked up in using the relative path to the test.

[Mads Ager (google), 2011/11/09 15:12:35]

OK, in that case should you make the directory listing recursive? Right now you
will never get anything that wasn't already covered I think?

+        filename.indexOf(directoryPath) + directoryPath.length + 1,
+        filename.length - ".dart".length);
+    Set<String> expectations = testSettingMap.expectations(testName);

[Mads Ager (google), 2011/11/09 14:46:53]

I would leave this out for now as well. It doesn't do anything?

[Bill Hesse, 2011/11/09 14:55:39]

I wanted the design, and the stubs.  That way, I can implement the stubs one by
one and keep it working..

[Mads Ager (google), 2011/11/09 15:12:35]

Same as above. I would wait until it does something. The design might change
when you start implementing it and I find it confusing to have an unimplemented
design in the code. Let's add it as we implement it?

+    expectations.addAll(ExpectationsFromFile(filename));
+    if (expectations.contains(SKIP)) return;
+
+    doTest(new TestCase(testName,
+                        shellPath,
+                        <String>["--enable_type_checks",
+                                 "--ignore-unrecognized-flags",
+                                 filename ],
+                        completeHandler,
+                        expectations));
   }
   
   void completeHandler(TestCase testCase) {
     TestOutput output = testCase.output;
     print("Exit code: ${output.exitCode} Time: ${output.time}");
   }
 }
+
+
+class Configuration {
+  Map<String, String> environment;
+
+  Configuration(this.environment);
+
+  bool isEnabled(Section section) =>
+      section.condition == null || section.condition.evaluate(environment);
+}
+
+class TestSettingMap {
+  TestSettingMap();
+
+  void addTest(testSetting, Configuration configuration) { }
+
+  Set<String> expectations(String filename) =>
+      new Set.from([PASS, FAIL, CRASH, TIMEOUT]);
+}
+
+
+Collection<String> ExpectationsFromFile(String fileName) {
+  return new List<String>();
+}