Removes old way to specify files to look for

test/analyzer/gyptest-analyzer.py

 #!/usr/bin/env python
 # Copyright (c) 2014 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Tests for analyzer
 """
 
 import json
 import TestGyp
 
-# TODO(sky): when done migrating recipes rename to gyptest-analyzer and nuke
-# existing gyptest-analyzer.
-
 found = 'Found dependency'
 not_found = 'No dependencies'
 
+
 def _CreateTestFile(files, targets):
   f = open('test_file', 'w')
   to_write = {'files': files, 'targets': targets }
   json.dump(to_write, f)
   f.close()
 
+
 def _CreateBogusTestFile():
   f = open('test_file','w')
   f.write('bogus')
   f.close()
 
+
 def _ReadOutputFileContents():
   f = open('analyzer_output', 'r')
   result = json.load(f)
   f.close()
   return result
 
+
 # NOTE: this would be clearer if it subclassed TestGypCustom, but that trips
 # over a bug in pylint (E1002).
 test = TestGyp.TestGypCustom(format='analyzer')
 
+
 def run_analyzer(*args, **kw):
   """Runs the test specifying a particular config and output path."""
   args += ('-Gconfig_path=test_file',
            '-Ganalyzer_output_path=analyzer_output')
   test.run_gyp('test.gyp', *args, **kw)
 
+
 def run_analyzer2(*args, **kw):
   """Runs the test specifying a particular config and output path."""
   args += ('-Gconfig_path=test_file',
            '-Ganalyzer_output_path=analyzer_output')
   test.run_gyp('test2.gyp', *args, **kw)
 
+
 def EnsureContains(targets=set(), matched=False):
   """Verifies output contains |targets|."""
   result = _ReadOutputFileContents()
   if result.get('error', None):
     print 'unexpected error', result.get('error')
     test.fail_test()
 
   if result.get('warning', None):
     print 'unexpected warning', result.get('warning')
     test.fail_test()
 
   actual_targets = set(result['targets'])
   if actual_targets != targets:
     print 'actual targets:', actual_targets, '\nexpected targets:', targets
     test.fail_test()
 
   if matched and result['status'] != found:
     print 'expected', found, 'got', result['status']
     test.fail_test()
   elif not matched and result['status'] != not_found:
     print 'expected', not_found, 'got', result['status']
     test.fail_test()
 
+
 def EnsureError(expected_error_string):
   """Verifies output contains the error string."""
   result = _ReadOutputFileContents()
   if result.get('error', '').find(expected_error_string) == -1:
     print 'actual error:', result.get('error', ''), '\nexpected error:', \
         expected_error_string
     test.fail_test()
 
+
+def EnsureStdoutContains(expected_error_string):
+  if test.stdout().find(expected_error_string) == -1:
+    print 'actual stdout:', test.stdout(), '\nexpected stdout:', \
+        expected_error_string
+    test.fail_test()
+
+
 def EnsureWarning(expected_warning_string):
   """Verifies output contains the warning string."""
   result = _ReadOutputFileContents()
   if result.get('warning', '').find(expected_warning_string) == -1:
     print 'actual warning:', result.get('warning', ''), \
         '\nexpected warning:', expected_warning_string
     test.fail_test()
 
-# Verifies file_path must be specified.
-test.run_gyp('test.gyp',
-             stdout='Must specify files to analyze via file_path generator '
-             'flag\n')
+
+# Verifies config_path must be specified.
+test.run_gyp('test.gyp')
+EnsureStdoutContains('Must specify files to analyze via config_path')
 
 # Verifies config_path must point to a valid file.
 test.run_gyp('test.gyp', '-Gconfig_path=bogus_file',
              '-Ganalyzer_output_path=analyzer_output')
 EnsureError('Unable to open file bogus_file')
 
 # Verify get error when bad target is specified.
 _CreateTestFile(['exe2.c'], ['bad_target'])
 run_analyzer()
 EnsureWarning('Unable to find all targets')
@@ skipping 116 matching lines @@
 _CreateTestFile(['test2.includes.gypi'], ['exe', 'exe2', 'foo', 'exe3'])
 run_analyzer2()
 EnsureContains(matched=True, targets={'exe', 'exe2', 'exe3'})
 
 # Verify modifying a file included makes all targets dirty.
 _CreateTestFile(['common.gypi'], ['exe', 'exe2', 'foo', 'exe3'])
 run_analyzer2('-Icommon.gypi')
 EnsureContains(matched=True, targets={'exe', 'foo', 'exe2', 'exe3'})
 
 test.pass_test()