Enable no-compile tests on Windows

tools/nocompile_driver.py

 #!/usr/bin/env python
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Implements a simple "negative compile" test for C++ on linux.
 
 Sometimes a C++ API needs to ensure that various usages cannot compile. To
 enable unittesting of these assertions, we use this python script to
 invoke gcc on a source file and assert that compilation fails.
@@ skipping 194 matching lines @@
                       was aborted.  If the test completed successfully,
                       this value is 0.
         'finished_at': A timestamp in seconds since the epoch for when this
                        test was successfully complete.  If the test is aborted,
                        or running, this value is 0.
         'expectations': A dictionary with the test expectations. See
                         ParseExpectation() for the structure.
         }
   """
   # TODO(ajwong): Get the compiler from gyp.
-  cmdline = [os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                          '../third_party/llvm-build/Release+Asserts/bin',
-                          'clang++')]
+  llvm_path = os.path.join(
+      os.path.dirname(os.path.realpath(__file__)),
+      '..', 'third_party', 'llvm-build', 'Release+Asserts', 'bin')
+  if os.name == 'nt':
+    clang = os.path.join(llvm_path, 'clang-cl.exe')
+  else:
+    clang = os.path.join(llvm_path, 'clang++')
+  cmdline = [clang]
   cmdline.extend(shlex.split(cflags))
   name = config['name']
   expectations = config['expectations']
   if expectations is not None:
     cmdline.append('-D%s' % name)
-  cmdline.extend(['-std=c++11', '-o', '/dev/null', '-c', '-x', 'c++',
-                  sourcefile_path])
+  if os.name == 'nt':
+    cmdline.extend(['/TP', '/c', sourcefile_path])
+  else:
+    cmdline.extend(['-std=c++11', '-o', '/dev/null', '-c', '-x', 'c++',
+                    sourcefile_path])
 
   process = subprocess.Popen(cmdline, stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE)
   now = time.time()
   return {'proc': process,
           'cmdline': ' '.join(cmdline),
           'name': name,
           'suite_name': config['suite_name'],
           'terminate_timeout': now + NCTEST_TERMINATE_TIMEOUT_SEC,
           'kill_timeout': now + NCTEST_KILL_TIMEOUT_SEC,
@@ skipping 132 matching lines @@
   finished_tests = []
   busy_loop_timeout = time.time() + BUSY_LOOP_MAX_TIME_SEC
   while len(finished_tests) == 0:
     # If we don't make progress for too long, assume the code is just dead.
     assert busy_loop_timeout > time.time()
 
     # Select on the output pipes.
     read_set = []
     for test in executing_tests.values():
       read_set.extend([test['proc'].stderr, test['proc'].stdout])
-    select.select(read_set, [], read_set, NCTEST_TERMINATE_TIMEOUT_SEC)
+    if os.name == 'nt':
+      # select cannot handle pipes on Windows.
+      time.sleep(0.1)
+    else:
+      select.select(read_set, [], read_set, NCTEST_TERMINATE_TIMEOUT_SEC)
 
     # Now attempt to process results.
     now = time.time()
     for test in executing_tests.values():
       proc = test['proc']
       if proc.poll() is not None:
         test['finished_at'] = now
         finished_tests.append(test)
       elif test['terminate_timeout'] < now:
         proc.terminate()
@@ skipping 38 matching lines @@
   resultfile = StringIO.StringIO()
   resultlog = StringIO.StringIO()
   resultfile.write(RESULT_FILE_HEADER % sourcefile_path)
 
   # Run the no-compile tests, but ensure we do not run more than |parallelism|
   # tests at once.
   timings['header_written'] = time.time()
   executing_tests = {}
   finished_tests = []
 
+  cflags_extra = ''
+  if os.name != 'nt':
+    cflags_extra = ' -MMD -MF %s.d -MT %s' % (resultfile_path, resultfile_path)
+
   test = StartTest(
       sourcefile_path,
-      cflags + ' -MMD -MF %s.d -MT %s' % (resultfile_path, resultfile_path),
+      cflags + cflags_extra,
       { 'name': 'NCTEST_SANITY',
         'suite_name': suite_name,
         'expectations': None,
       })
   executing_tests[test['name']] = test
 
   for config in test_configs:
     # CompleteAtLeastOneTest blocks until at least one test finishes. Thus, this
     # acts as a semaphore.  We cannot use threads + a real semaphore because
     # subprocess forks, which can cause all sorts of hilarity with threads.
@@ skipping 31 matching lines @@
   if return_code == 0:
     with open(resultfile_path, 'w') as fd:
       fd.write(resultfile.getvalue())
 
   resultfile.close()
   sys.exit(return_code)
 
 
 if __name__ == '__main__':
   main()