remove unittest as a test status, instead record this at test build time

pkg/dev_compiler/test/codegen_test.dart

 // Copyright (c) 2016, 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.
 
 /// Tests code generation.
 ///
 /// Runs Dart Dev Compiler on all input in the `codegen` directory and checks
 /// that the output is what we expected.
 library dev_compiler.test.codegen_test;
 
@@ skipping 148 matching lines @@
       var exception, stackTrace;
       try {
         module = compiler.compile(unit, options);
       } catch (e, st) {
         exception = e;
         stackTrace = st;
       }
 
       // This covers tests where the intent of the test is to validate that
       // some static error is produced.
-      var intentionalCompileError =
-          contents.contains(': compile-time error') ||
-              contents.contains('/*@compile-error=');
+      var intentionalCompileError = contents.contains(': compile-time error') ||
+          contents.contains('/*@compile-error=');
 
       // This covers tests that should not produce a static error but that
       // currently do due to issues in our implementation.
       var knownCompileError = compileErrorTests.contains(name);
 
       var crashing = _crashingTests.contains(name);
       var inconsistent = _inconsistentTests.contains(name);
 
       if (module == null) {
         expect(crashing, isTrue,
@@ skipping 14 matching lines @@
       if (inconsistent) {
         // An inconsistent test will only compile on some platforms (see
         // comment below). It should not crash however.
       } else if (module.isValid) {
         // TODO(vsm): We don't seem to trip on non-strong errors?
         // expect(expectedCompileTimeError, isFalse,
         //    reason: "test $name expected compilation errors, but compiled.");
         expect(knownCompileError, isFalse,
             reason: "test $name expected static errors, but compiled.");
       } else {
-        var reason = intentionalCompileError
-            ? "intended"
-            : "unexpected";
+        var reason = intentionalCompileError ? "intended" : "unexpected";
         expect(intentionalCompileError || knownCompileError, isTrue,
             reason: "test $name failed to compile due to $reason errors:"
                 "\n\n${module.errors.join('\n')}.");
       }
     });
   }
 
   if (filePattern.hasMatch('sunflower')) {
     test('sunflower', () {
       _buildSunflower(sharedCompiler, codegenOutputDir, codegenExpectDir);
@@ skipping 77 matching lines @@
           path.join(testDirectory, '..', '..', '..', 'tests', sdkTestDir);
 
       if (!new Directory(inputPath).existsSync()) continue;
 
       for (var file in _listFiles(inputPath, recursive: true)) {
         var relativePath = path.relative(file, from: inputPath);
         var outputPath = path.join(codegenTestDir, testDir, relativePath);
 
         _ensureDirectory(path.dirname(outputPath));
 
-        // Copy it over. We do this even for multitests because import_self_test
-        // is a multitest, yet imports its own unexpanded form (!).
-        new File(file).copySync(outputPath);
+        if (file.endsWith("_test.dart")) {
 
-        if (file.endsWith("_test.dart")) {
+          void _writeTest(String outputPath, String contents) {
+            if (contents.contains('package:unittest/')) {
+              // TODO(jmesserly): we could use directive parsing, but that
+              // feels like overkill.
+              // Alternatively, we could detect "unittest" use at runtime.
+              // We really need a better solution for Karma+mocha+unittest
+              // integration.
+              contents += '\nfinal _usesUnittestPackage = true;\n';
+            }
+            new File(outputPath).writeAsStringSync(contents);
+          }
+
           var contents = new File(file).readAsStringSync();
-
           if (isMultiTest(contents)) {
             // It's a multitest, so expand it and add all of the variants.
             var tests = <String, String>{};
             var outcomes = <String, Set<String>>{};
             extractTestsFromMultitest(file, contents, tests, outcomes);
 
             var fileName = path.basenameWithoutExtension(file);
             var outputDir = path.dirname(outputPath);
             tests.forEach((name, contents) {
               var multiFile =
                   path.join(outputDir, '${fileName}_${name}_multi.dart');
               testFiles.add(multiFile);
 
-              new File(multiFile).writeAsStringSync(contents);
+              _writeTest(multiFile, contents);
             });
           } else {
             // It's a single test suite.
             testFiles.add(outputPath);
           }
+
+          // Write the test file.
+          //
+          // We do this even for multitests because import_self_test
+          // is a multitest, yet imports its own unexpanded form (!).
+          _writeTest(outputPath, contents);
+
+        } else {
+          // Copy the non-test file over, in case it is used as an import.
+          new File(file).copySync(outputPath);
         }
       }
     }
   }
 
   // Also include the other special files that live at the top level directory.
   for (var file in _listFiles(codegenDir)) {
     var relativePath = path.relative(file, from: codegenDir);
     var outputPath = path.join(codegenTestDir, relativePath);
 
@@ skipping 79 matching lines @@
 final _crashingTests = new Set<String>.from([
   // TODO(vsm): Fix these - they import files from a different directory
   // - this triggers an invalid library root build error.
   'lib/html/custom/attribute_changed_callback_test',
   'lib/html/custom/constructor_calls_created_synchronously_test',
   'lib/html/custom/entered_left_view_test',
   'lib/html/custom/js_custom_test',
   'lib/html/custom/mirrors_test',
   'lib/html/custom/regress_194523002_test',
 ].map((p) => p.replaceAll('/', path.separator)));