[clang-tidy] Use a python script instead of a shell script to run clang-tidy tests.

[alexfh]

Summary

Add check_clang_tidy.py script that is functionally identical to the
check_clang_tidy.py, but should also be functional on windows.

I've verified that the script works on linux. Would be nice if folks using
Windows could test the patch before I break windows bots ;)

[alexfh]

Removed an unused import.

[aaron.ballman]

Yay! I'm really excited for this! Unfortunately, it fails all over the place on Windows. The errors are all in the form:

58> ****
58> FAIL: Clang Tools :: clang-tidy/readability-simplify-bool-expr-chained-conditional-return.cpp (7280 of 23187)
58> **** TEST 'Clang Tools :: clang-tidy/readability-simplify-bool-expr-chained-conditional-return.cpp' FAILED ****
58> Script:
58> --
58> $(dirname E:\llvm\llvm\tools\clang\tools\extra\test\clang-tidy\readability-simplify-bool-expr-chained-conditional-return.cpp)/check_clang_tidy.py E:\llvm\llvm\tools\clang\tools\extra\test\clang-tidy\readability-simplify-bool-expr-chained-conditional-return.cpp readability-simplify-boolean-expr E:\llvm\2015\tools\clang\tools\extra\test\clang-tidy\Output\readability-simplify-bool-expr-chained-conditional-return.cpp.tmp -config="{CheckOptions: [:+"readability-simplify-boolean-expr.ChainedConditionalReturn",+value:+1]}" --
58> --
58> Exit Code: 127
58>
58> Command Output (stdout):
58> --
58> Command 0: "$(dirname" "E:\llvm\llvm\tools\clang\tools\extra\test\clang-tidy\readability-simplify-bool-expr-chained-conditional-return.cpp)/check_clang_tidy.py" "E:\llvm\llvm\tools\clang\tools\extra\test\clang-tidy\readability-simplify-bool-expr-chained-conditional-return.cpp" "readability-simplify-boolean-expr" "E:\llvm\2015\tools\clang\tools\extra\test\clang-tidy\Output\readability-simplify-bool-expr-chained-conditional-return.cpp.tmp" "-config={CheckOptions: [:+readability-simplify-boolean-expr.ChainedConditionalReturn,+value:+1]}" "--"
58> Command 0 Result: 127
58> Command 0 Output:
58>
58>
58> Command 0 Stderr:
58> '$(dirname': command not found
58>
58>
58> --
58>
58> ****
58> FAIL: Clang Tools :: clang-tidy/readability-identifier-naming.cpp (7281 of 23187)
58> **** TEST 'Clang Tools :: clang-tidy/readability-identifier-naming.cpp' FAILED ****
58> Script:
58> --
58> $(dirname E:\llvm\llvm\tools\clang\tools\extra\test\clang-tidy\readability-identifier-naming.cpp)/check_clang_tidy.py E:\llvm\llvm\tools\clang\tools\extra\test\clang-tidy\readability-identifier-naming.cpp readability-identifier-naming E:\llvm\2015\tools\clang\tools\extra\test\clang-tidy\Output\readability-identifier-naming.cpp.tmp -config='{CheckOptions: [ :+readability-identifier-naming.AbstractClassCase,+value:+CamelCase, :+readability-identifier-naming.AbstractClassPrefix,+value:+'A', :+readability-identifier-naming.ClassCase,+value:+CamelCase, :+readability-identifier-naming.ClassPrefix,+value:+'C', :+readability-identifier-naming.ClassConstantCase,+value:+CamelCase, :+readability-identifier-naming.ClassConstantPrefix,+value:+'k', :+readability-identifier-naming.ClassMemberCase,+value:+CamelCase, :+readability-identifier-naming.ClassMethodCase,+value:+camelBack, :+readability-identifier-naming.ConstantCase,+value:+UPPER_CASE, :+readability-identifier-naming.ConstantSuffix,+value:+'_CST', :+readability-identifier-naming.ConstexprFunctionCase,+value:+lower_case, :+readability-identifier-naming.ConstexprMethodCase,+value:+lower_case, :+readability-identifier-naming.ConstexprVariableCase,+value:+lower_case, :+readability-identifier-naming.EnumCase,+value:+CamelCase, :+readability-identifier-naming.EnumPrefix,+value:+'E', :+readability-identifier-naming.EnumConstantCase,+value:+UPPER_CASE, :+readability-identifier-naming.FunctionCase,+value:+camelBack, :+readability-identifier-naming.GlobalConstantCase,+value:+UPPER_CASE, :+readability-identifier-naming.GlobalFunctionCase,+value:+CamelCase, :+readability-identifier-naming.GlobalVariableCase,+value:+lower_case, :+readability-identifier-naming.GlobalVariablePrefix,+value:+'g_', :+readability-identifier-naming.InlineNamespaceCase,+value:+lower_case, :+readability-identifier-naming.LocalConstantCase,+value:+CamelCase, :+readability-identifier-naming.LocalConstantPrefix,+value:+'k', :+readability-identifier-naming.LocalVariableCase,+value:+lower_case, :+readability-identifier-naming.MemberCase,+value:+CamelCase, :+readability-identifier-naming.MemberPrefix,+value:+'m_', :+readability-identifier-naming.ConstantMemberCase,+value:+lower_case, :+readability-identifier-naming.PrivateMemberPrefix,+value:+'__', :+readability-identifier-naming.ProtectedMemberPrefix,+value:+'_', :+readability-identifier-naming.PublicMemberCase,+value:+lower_case, :+readability-identifier-naming.MethodCase,+value:+camelBack, :+readability-identifier-naming.PrivateMethodPrefix,+value:+'__', :+readability-identifier-naming.ProtectedMethodPrefix,+value:+'_', :+readability-identifier-naming.NamespaceCase,+value:+lower_case, :+readability-identifier-naming.ParameterCase,+value:+camelBack, :+readability-identifier-naming.ParameterPrefix,+value:+'a_', :+readability-identifier-naming.ConstantParameterCase,+value:+camelBack, :+readability-identifier-naming.ConstantParameterPrefix,+value:+'i_', :+readability-identifier-naming.ParameterPackCase,+value:+camelBack, :+readability-identifier-naming.PureFunctionCase,+value:+lower_case, :+readability-identifier-naming.PureMethodCase,+value:+camelBack, :+readability-identifier-naming.StaticConstantCase,+value:+UPPER_CASE, :+readability-identifier-naming.StaticVariableCase,+value:+camelBack, :+readability-identifier-naming.StaticVariablePrefix,+value:+'s_', :+readability-identifier-naming.StructCase,+value:+lower_case, :+readability-identifier-naming.TemplateParameterCase,+value:+UPPER_CASE, :+readability-identifier-naming.TemplateTemplateParameterCase,+value:+CamelCase, :+readability-identifier-naming.TemplateUsingCase,+value:+lower_case, :+readability-identifier-naming.TemplateUsingPrefix,+value:+'u_', :+readability-identifier-naming.TypeTemplateParameterCase,+value:+camelBack, :+readability-identifier-naming.TypeTemplateParameterSuffix,+value:+'_t', :+readability-identifier-naming.TypedefCase,+value:+lower_case, :+readability-identifier-naming.TypedefSuffix,+value:+'_t', :+readability-identifier-naming.UnionCase,+value:+CamelCase, :+readability-identifier-naming.UnionPrefix,+value:+'U', :+readability-identifier-naming.UsingCase,+value:+lower_case, :+readability-identifier-naming.ValueTemplateParameterCase,+value:+camelBack, :+readability-identifier-naming.VariableCase,+value:+lower_case, :+readability-identifier-naming.VirtualMethodCase,+value:+UPPER_CASE, :+readability-identifier-naming.VirtualMethodPrefix,+value:+'v_', :+readability-identifier-naming.IgnoreFailedSplit,+value:+0 ]}' -- -std=c++11 -fno-delayed-template-parsing
58> --
58> Exit Code: 127
58>
58> Command Output (stdout):
58> --
58> Command 0: "$(dirname" "E:\llvm\llvm\tools\clang\tools\extra\test\clang-tidy\readability-identifier-naming.cpp)/check_clang_tidy.py" "E:\llvm\llvm\tools\clang\tools\extra\test\clang-tidy\readability-identifier-naming.cpp" "readability-identifier-naming" "E:\llvm\2015\tools\clang\tools\extra\test\clang-tidy\Output\readability-identifier-naming.cpp.tmp" "-config={CheckOptions: [ :+readability-identifier-naming.AbstractClassCase,+value:+CamelCase, :+readability-identifier-naming.AbstractClassPrefix,+value:+A, :+readability-identifier-naming.ClassCase,+value:+CamelCase, :+readability-identifier-naming.ClassPrefix,+value:+C, :+readability-identifier-naming.ClassConstantCase,+value:+CamelCase, :+readability-identifier-naming.ClassConstantPrefix,+value:+k, :+readability-identifier-naming.ClassMemberCase,+value:+CamelCase, :+readability-identifier-naming.ClassMethodCase,+value:+camelBack, :+readability-identifier-naming.ConstantCase,+value:+UPPER_CASE, :+readability-identifier-naming.ConstantSuffix,+value:+_CST, :+readability-identifier-naming.ConstexprFunctionCase,+value:+lower_case, :+readability-identifier-naming.ConstexprMethodCase,+value:+lower_case, :+readability-identifier-naming.ConstexprVariableCase,+value:+lower_case, :+readability-identifier-naming.EnumCase,+value:+CamelCase, :+readability-identifier-naming.EnumPrefix,+value:+E, :+readability-identifier-naming.EnumConstantCase,+value:+UPPER_CASE, :+readability-identifier-naming.FunctionCase,+value:+camelBack, :+readability-identifier-naming.GlobalConstantCase,+value:+UPPER_CASE, :+readability-identifier-naming.GlobalFunctionCase,+value:+CamelCase, :+readability-identifier-naming.GlobalVariableCase,+value:+lower_case, :+readability-identifier-naming.GlobalVariablePrefix,+value:+g_, :+readability-identifier-naming.InlineNamespaceCase,+value:+lower_case, :+readability-identifier-naming.LocalConstantCase,+value:+CamelCase, :+readability-identifier-naming.LocalConstantPrefix,+value:+k, :+readability-identifier-naming.LocalVariableCase,+value:+lower_case, :+readability-identifier-naming.MemberCase,+value:+CamelCase, :+readability-identifier-naming.MemberPrefix,+value:+m_, :+readability-identifier-naming.ConstantMemberCase,+value:+lower_case, :+readability-identifier-naming.PrivateMemberPrefix,+value:+__, :+readability-identifier-naming.ProtectedMemberPrefix,+value:+_, :+readability-identifier-naming.PublicMemberCase,+value:+lower_case, :+readability-identifier-naming.MethodCase,+value:+camelBack, :+readability-identifier-naming.PrivateMethodPrefix,+value:+__, :+readability-identifier-naming.ProtectedMethodPrefix,+value:+_, :+readability-identifier-naming.NamespaceCase,+value:+lower_case, :+readability-identifier-naming.ParameterCase,+value:+camelBack, :+readability-identifier-naming.ParameterPrefix,+value:+a_, :+readability-identifier-naming.ConstantParameterCase,+value:+camelBack, :+readability-identifier-naming.ConstantParameterPrefix,+value:+i_, :+readability-identifier-naming.ParameterPackCase,+value:+camelBack, :+readability-identifier-naming.PureFunctionCase,+value:+lower_case, :+readability-identifier-naming.PureMethodCase,+value:+camelBack, :+readability-identifier-naming.StaticConstantCase,+value:+UPPER_CASE, :+readability-identifier-naming.StaticVariableCase,+value:+camelBack, :+readability-identifier-naming.StaticVariablePrefix,+value:+s_, :+readability-identifier-naming.StructCase,+value:+lower_case, :+readability-identifier-naming.TemplateParameterCase,+value:+UPPER_CASE, :+readability-identifier-naming.TemplateTemplateParameterCase,+value:+CamelCase, :+readability-identifier-naming.TemplateUsingCase,+value:+lower_case, :+readability-identifier-naming.TemplateUsingPrefix,+value:+u_, :+readability-identifier-naming.TypeTemplateParameterCase,+value:+camelBack, :+readability-identifier-naming.TypeTemplateParameterSuffix,+value:+_t, :+readability-identifier-naming.TypedefCase,+value:+lower_case, :+readability-identifier-naming.TypedefSuffix,+value:+_t, :+readability-identifier-naming.UnionCase,+value:+CamelCase, :+readability-identifier-naming.UnionPrefix,+value:+U, :+readability-identifier-naming.UsingCase,+value:+lower_case, :+readability-identifier-naming.ValueTemplateParameterCase,+value:+camelBack, :+readability-identifier-naming.VariableCase,+value:+lower_case, :+readability-identifier-naming.VirtualMethodCase,+value:+UPPER_CASE, :+readability-identifier-naming.VirtualMethodPrefix,+value:+v_, :+readability-identifier-naming.IgnoreFailedSplit,+value:+0 ]}" "--" "-std=c++11" "-fno-delayed-template-parsing"
58> Command 0 Result: 127
58> Command 0 Output:
58>
58>
58> Command 0 Stderr:
58> '$(dirname': command not found
58>
58>
58> --
58>
58> ****

Is dirname something lit is supposed to be handling for us, or is that a shell command that's not supported on Windows?

~Aaron

[chapuni]

Alex, thanks for your working. I tweaked to run on my hosts.

• mingw-w64 with Py3.3
• Linux with Py2.7 and Py3.4

My change is here; https://github.com/chapuni/llvm-project/commit/0f4a303bdc7b925f42c0cd48817052d2b49b2234
Could you merge it, please?

test/clang-tidy/arg-comments.cpp

1

$(dirname %s) assumes shell. use %S instead.
Lit internal runner is not capable of !shbang. use %python.

// RUN: %python %S/check_clang_tidy.py %s misc-argument-comment %t

test/clang-tidy/check_clang_tidy.py

71

It is not string, but bytes. It wouldn't run on py3.

+  clang_tidy_output = subprocess.check_output(args, stderr=subprocess.STDOUT).decode()

85

It cannot be concatenated to string. Use encode.

+        diff_output.decode() +

test/clang-tidy/google-readability-casting.c

7

It can be pruned.

test/clang-tidy/misc-unused-parameters.cpp

5

It can be pruned.

[alexfh]

Addressed review comments.

[alexfh]

test/clang-tidy/arg-comments.cpp

1

Sure, I should have noticed this. Thanks for pointing out!

test/clang-tidy/google-readability-casting.c

7

Line 5 runs cp, will it work on Windows?

[chapuni]

Ready to commit regardless of one REQUIRES.

Testing Time: 4.73s
  Expected Passes    : 72

Note, llvm-include-order.cpp will XFAIL for targeting msvc.

test/clang-tidy/google-readability-casting.c

7

It should work.
We require GnuWin32 to run tests on Windows. It has cp(1).

[aaron.ballman]

The latest patch works for me when testing on Windows with MSVC. LGTM, and thank you!

[alexfh]

test/clang-tidy/google-readability-casting.c

7

Removed REQUIRES: shell.

test/clang-tidy/arg-comments.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-argument-comment %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-argument-comment %t
 
 // FIXME: clang-tidy should provide a -verify mode to make writing these checks
 // easier and more accurate.
 
 void ffff(int xxxx, int yyyy);
 
 void f(int x, int y);
 void g() {

test/clang-tidy/check_clang_tidy.py

+#!/usr/bin/python
+#
+#===- check_clang_tidy.py - ClangTidy Test Helper ------------*- python -*--===#
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+#===------------------------------------------------------------------------===#
+
+r"""
+ClangTidy Test Helper
+=====================
+
+This script runs clang-tidy in fix mode and verify fixes, messages or both.
+
+Usage:
+  check_clang_tidy.py <source-file> <check-name> <temp-file> \
+    [optional clang-tidy arguments]
+
+Example:
+  // RUN: $(dirname %s)/check_clang_tidy.py %s llvm-include-order %t -- -isystem $(dirname %s)/Inputs/Headers
+"""
+
+import re
+import subprocess
+import sys
+
+
+def write_file(file_name, text):
+  with open(file_name, 'w') as f:
+    f.write(text)
+    f.truncate()
+
+def main():
+  if len(sys.argv) < 4:
+    sys.exit('Not enough arguments.')
+
+  input_file_name = sys.argv[1]
+  check_name = sys.argv[2]
+  temp_file_name = sys.argv[3] + '.cpp'
+
+  clang_tidy_extra_args = sys.argv[4:]
+  if len(clang_tidy_extra_args) == 0:
+    clang_tidy_extra_args = ['--', '--std=c++11']
+
+  with open(input_file_name, 'r') as input_file:
+    input_text = input_file.read()
+
+  has_check_fixes = input_text.find('CHECK-FIXES') >= 0
+  has_check_messages = input_text.find('CHECK-MESSAGES') >= 0
+
+  if not has_check_fixes and not has_check_messages:
+    sys.exit('Neither CHECK-FIXES nor CHECK-MESSAGES found in the input')
+
+  # Remove the contents of the CHECK lines to avoid CHECKs matching on
+  # themselves.  We need to keep the comments to preserve line numbers while
+  # avoiding empty lines which could potentially trigger formatting-related
+  # checks.
+  cleaned_test = re.sub('// *CHECK-[A-Z-]*:[^\r\n]*', '//', input_text)
+
+  write_file(temp_file_name, cleaned_test)
+
+  original_file_name = temp_file_name + ".orig"
+  write_file(original_file_name, cleaned_test)
+
+  args = ['clang-tidy', temp_file_name, '-fix', '--checks=-*,' + check_name] + \
+        clang_tidy_extra_args
+  print('Running ' + repr(args) + '...')
+  clang_tidy_output = subprocess.check_output(args, stderr=subprocess.STDOUT)
+
+  print('------------------------ clang-tidy output -----------------------\n' +
+        clang_tidy_output +
+        '\n------------------------------------------------------------------')
+
+  try:
+    diff_output = subprocess.check_output(
+        ['diff', '-u', original_file_name, temp_file_name],
+        stderr=subprocess.STDOUT)
+  except subprocess.CalledProcessError as e:
+    diff_output = e.output
+
+  print('------------------------------ Fixes -----------------------------\n' +
+        diff_output +
+        '\n------------------------------------------------------------------')
+
+  if has_check_fixes:
+    try:
+      subprocess.check_output(
+          ['FileCheck', '-input-file=' + temp_file_name, input_file_name,
+           '-check-prefix=CHECK-FIXES', '-strict-whitespace'],
+          stderr=subprocess.STDOUT)
+    except subprocess.CalledProcessError as e:
+      print('FileCheck failed:\n' + e.output)
+      raise
+
+  if has_check_messages:
+    messages_file = temp_file_name + '.msg'
+    write_file(messages_file, clang_tidy_output)
+    try:
+      subprocess.check_output(
+          ['FileCheck', '-input-file=' + messages_file, input_file_name,
+           '-check-prefix=CHECK-MESSAGES',
+           '-implicit-check-not={{warning|error}}:'],
+          stderr=subprocess.STDOUT)
+    except subprocess.CalledProcessError as e:
+      print('FileCheck failed:\n' + e.output)
+      raise
+
+if __name__ == '__main__':
+  main()

test/clang-tidy/google-explicit-constructor.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s google-explicit-constructor %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s google-explicit-constructor %t
 
 namespace std {
   typedef decltype(sizeof(int)) size_t;
 
   // libc++'s implementation
   template <class _E>
   class initializer_list
   {

test/clang-tidy/google-explicit-make-pair.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s google-build-explicit-make-pair %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s google-build-explicit-make-pair %t
 
 namespace std {
 template <class T1, class T2>
 struct pair {
   pair(T1 x, T2 y) {}
 };
 
 template <class T1, class T2>

test/clang-tidy/google-member-string-references.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-member-string-references %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s google-runtime-member-string-references %t
 
 namespace std {
 template<typename T>
   class basic_string {};
 
 typedef basic_string<char> string;
 }
 

test/clang-tidy/google-memset-zero-length.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-memset %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s google-runtime-memset %t
 
 void *memset(void *, int, __SIZE_TYPE__);
 
 namespace std {
   using ::memset;
 }
 
 template <int i, typename T>

test/clang-tidy/google-overloaded-unary-and.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-operator %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s google-runtime-operator %t
 
 struct Foo {
   void *operator&();
 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not overload unary operator&, it is dangerous. [google-runtime-operator]
 };
 
 template <typename T>
 struct TFoo {

test/clang-tidy/google-readability-casting.c

-// RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-casting %t -- -x c
+// RUN: $(dirname %s)/check_clang_tidy.py %s google-readability-casting %t -- -x c
 // The testing script always adds .cpp extension to the input file name, so we
 // need to run clang-tidy directly in order to verify handling of .c files:
 // RUN: clang-tidy --checks=-*,google-readability-casting %s -- -x c++ | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not='{{warning|error}}:'
 // RUN: cp %s %t.main_file.cpp
 // RUN: clang-tidy --checks=-*,google-readability-casting -header-filter='.*' %t.main_file.cpp -- -I%S -DTEST_INCLUDE -x c++ | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not='{{warning|error}}:'
 // REQUIRES: shell
 
 #ifdef TEST_INCLUDE
 
 #undef TEST_INCLUDE
 #include "google-readability-casting.c"
 
 #else
 
 void f(const char *cpc) {
   const char *cpc2 = (const char*)cpc;
   // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: redundant cast to the same type [google-readability-casting]
   // CHECK-FIXES: const char *cpc2 = cpc;
   char *pc = (char*)cpc;
 }
 
 #endif

test/clang-tidy/google-readability-casting.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-casting %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s google-readability-casting %t
 
 bool g() { return false; }
 
 enum Enum { Enum1 };
 struct X {};
 struct Y : public X {};
 
 void f(int a, double b, const char *cpc, const void *cpv, X *pX) {

test/clang-tidy/google-readability-namespace-comments.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-namespace-comments %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s google-readability-namespace-comments %t
 
 namespace n1 {
 namespace n2 {
 
 
 
 
 

test/clang-tidy/google-readability-todo.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-todo %t -config="{User: 'some user'}" --
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s google-readability-todo %t -config="{User: 'some user'}" --
 
 //   TODOfix this1
 // CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
 // CHECK-FIXES: // TODO(some user): fix this1
 
 //   TODO fix this2
 // CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
 // CHECK-FIXES: // TODO(some user): fix this2

test/clang-tidy/google-runtime-int.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-int %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s google-runtime-int %t
 
 long a();
 // CHECK-MESSAGES: [[@LINE-1]]:1: warning: consider replacing 'long' with 'int{{..}}'
 
 typedef unsigned long long uint64; // NOLINT
 
 long b(long = 1);
 // CHECK-MESSAGES: [[@LINE-1]]:1: warning: consider replacing 'long' with 'int{{..}}'

test/clang-tidy/llvm-include-order.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s llvm-include-order %t -- -isystem %S/Inputs/Headers
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s llvm-include-order %t -- -isystem %S/Inputs/Headers
 
 // FIXME: Investigating.
 // XFAIL: win32
 
 // CHECK-MESSAGES: [[@LINE+2]]:1: warning: #includes are not sorted properly
 #include "j.h"
 #include "gtest/foo.h"
 #include "i.h"

test/clang-tidy/llvm-twine-local.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s llvm-twine-local %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s llvm-twine-local %t
 
 namespace llvm {
 class Twine {
 public:
   Twine(const char *);
   Twine(int);
   Twine &operator+(const Twine &);
 };

test/clang-tidy/misc-assert-side-effect.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-assert-side-effect %t -config="{CheckOptions: [{key: misc-assert-side-effect.CheckFunctionCalls, value: 1}, {key: misc-assert-side-effect.AssertMacros, value: 'assert,assert2,my_assert'}]}" -- -fexceptions
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-assert-side-effect %t -config="{CheckOptions: [{key: misc-assert-side-effect.CheckFunctionCalls, value: 1}, {key: misc-assert-side-effect.AssertMacros, value: 'assert,assert2,my_assert'}]}" -- -fexceptions
 
 //===--- assert definition block ------------------------------------------===//
 int abort() { return 0; }
 
 #ifdef NDEBUG
 #define assert(x) 1
 #else
 #define assert(x)                                                              \

test/clang-tidy/misc-assign-operator-signature.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-assign-operator-signature %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-assign-operator-signature %t
 
 struct Good {
   Good& operator=(const Good&);
   Good& operator=(Good&&);
 
   // Assign from other types is fine too.
   Good& operator=(int);
 };

test/clang-tidy/misc-bool-pointer-implicit-conversion.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-bool-pointer-implicit-conversion %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-bool-pointer-implicit-conversion %t
 
 bool *SomeFunction();
 void SomeOtherFunction(bool*);
 bool F();
 void G(bool);
 
 
 template <typename T>

test/clang-tidy/misc-inaccurate-erase.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-inaccurate-erase %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-inaccurate-erase %t
 
 namespace std {
 template <typename T> struct vec_iterator {
   T *ptr;
   vec_iterator operator++(int);
 };
 
 template <typename T> struct vector {

test/clang-tidy/misc-inefficient-algorithm.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-inefficient-algorithm %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-inefficient-algorithm %t
 
 namespace std {
 template <typename T> struct less {
   bool operator()(const T &lhs, const T &rhs) { return lhs < rhs; }
 };
 
 template <typename T> struct greater {
   bool operator()(const T &lhs, const T &rhs) { return lhs > rhs; }

test/clang-tidy/misc-macro-parentheses.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-macro-parentheses %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-macro-parentheses %t
 
 #define BAD1              -1
 // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: macro replacement list should be enclosed in parentheses [misc-macro-parentheses]
 #define BAD2              1+2
 // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: macro replacement list should be enclosed in parentheses [misc-macro-parentheses]
 #define BAD3(A)           (A+1)
 // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: macro argument should be enclosed in parentheses [misc-macro-parentheses]
 #define BAD4(x)           ((unsigned char)(x & 0xff))

test/clang-tidy/misc-noexcept-move-constructor.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-noexcept-move-constructor %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-noexcept-move-constructor %t
 
 class A {
   A(A &&);
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: move constructors should be marked noexcept [misc-noexcept-move-constructor]
   A &operator=(A &&);
   // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: move assignment operators should
 };
 

test/clang-tidy/misc-repeated-side-effects-in-macro.c

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-macro-repeated-side-effects %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-macro-repeated-side-effects %t
 
 #define badA(x,y)  ((x)+((x)+(y))+(y))
 void bad(int ret, int a, int b) {
   ret = badA(a++, b);
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: side effects in the 1st macro argument 'x' are repeated in macro expansion [misc-macro-repeated-side-effects]
   ret = badA(++a, b);
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: side effects in the 1st macro argument 'x'
   ret = badA(a--, b);

test/clang-tidy/misc-static-assert.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-static-assert %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-static-assert %t
 
 void abort() {}
 #ifdef NDEBUG
 #define assert(x) 1
 #else
 #define assert(x)                                                              \
   if (!(x))                                                                    \
   abort()

test/clang-tidy/misc-swapped-arguments.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-swapped-arguments %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-swapped-arguments %t
 
 void F(int, double);
 
 int SomeFunction();
 
 template <typename T, typename U>
 void G(T a, U b) {
   F(a, b); // no-warning

test/clang-tidy/misc-undelegated-constructor.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-undelegated-constructor %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-undelegated-constructor %t
 
 struct Ctor;
 Ctor foo();
 
 struct Ctor {
   Ctor();
   Ctor(int);
   Ctor(int, int);

test/clang-tidy/misc-uniqueptr-reset-release.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-uniqueptr-reset-release %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-uniqueptr-reset-release %t
 
 namespace std {
 
 template <typename T>
 struct default_delete {};
 
 template <typename T, class Deleter = std::default_delete<T>>
 struct unique_ptr {

test/clang-tidy/misc-unused-alias-decls.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-unused-alias-decls %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-unused-alias-decls %t
 
 namespace my_namespace {
 class C {};
 }
 
 namespace unused_alias = ::my_namespace; // eol-comments aren't removed (yet)
 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: namespace alias decl 'unused_alias' is unused
 // CHECK-FIXES: {{^}}// eol-comments aren't removed (yet)
 
 namespace used_alias = ::my_namespace;
 void f() { used_alias::C c; }

test/clang-tidy/misc-unused-parameters.c

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-unused-parameters %t -- -xc
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-unused-parameters %t -- -xc
 
 // Basic removal
 // =============
 void a(int i) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters]
 // CHECK-FIXES: {{^}}void a(int  /*i*/) {}{{$}}
 
 static void b(); // In C, forward declarations can leave out parameters.
 static void b(int i) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: parameter 'i' is unused [misc-unused-parameters]
 // CHECK-FIXES: {{^}}static void b() {}{{$}}
 
 // Unchanged cases
 // ===============
 void h(i, c, d) int i; char *c, *d; {} // Don't mess with K&R style
 

test/clang-tidy/misc-unused-parameters.cpp

 // RUN: echo "static void staticFunctionHeader(int i) {}" > %T/header.h
 // RUN: echo "static void staticFunctionHeader(int  /*i*/) {}" > %T/header-fixed.h
-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-unused-parameters %t -header-filter='.*' -- -fno-delayed-template-parsing
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-unused-parameters %t -header-filter='.*' -- -fno-delayed-template-parsing
 // RUN: diff %T/header.h %T/header-fixed.h
 // REQUIRES: shell
 
 #include "header.h"
 // CHECK-MESSAGES: header.h:1:38: warning
 
 // Basic removal
 // =============
 void a(int i) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters]

test/clang-tidy/misc-unused-raii.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-unused-raii %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-unused-raii %t
 
 struct Foo {
   Foo();
   Foo(int);
   Foo(int, int);
   ~Foo();
 };
 

test/clang-tidy/misc-use-override-cxx98.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-use-override %t -- -std=c++98
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-use-override %t -- -std=c++98
 
 struct Base {
   virtual ~Base() {}
   virtual void a();
   virtual void b();
 };
 
 struct SimpleCases : public Base {

test/clang-tidy/misc-use-override.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-use-override %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s misc-use-override %t
 
 #define ABSTRACT = 0
 
 #define OVERRIDE override
 #define VIRTUAL virtual
 #define NOT_VIRTUAL
 #define NOT_OVERRIDE
 

test/clang-tidy/modernize-loop-convert-basic.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s modernize-loop-convert %t -- -std=c++11 -I %S/Inputs/modernize-loop-convert
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s modernize-loop-convert %t -- -std=c++11 -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 namespace Array {
 
 const int N = 6;
 const int NMinusOne = N - 1;
 int arr[N] = {1, 2, 3, 4, 5, 6};

test/clang-tidy/modernize-loop-convert-extra.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s modernize-loop-convert %t -- -std=c++11 -I %S/Inputs/modernize-loop-convert
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s modernize-loop-convert %t -- -std=c++11 -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 namespace Dependency {
 
 void f() {
   const int N = 6;
   const int M = 8;

test/clang-tidy/modernize-loop-convert-negative.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s modernize-loop-convert %t -- -std=c++11 -I %S/Inputs/modernize-loop-convert
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s modernize-loop-convert %t -- -std=c++11 -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 // CHECK-FIXES-NOT: for ({{.*[^:]:[^:].*}})
 
 namespace Negative {
 
 const int N = 6;

test/clang-tidy/modernize-pass-by-value.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s modernize-pass-by-value %t -- -std=c++11 -fno-delayed-template-parsing
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s modernize-pass-by-value %t -- -std=c++11 -fno-delayed-template-parsing
 
 // CHECK-FIXES: #include <utility>
 
 namespace {
 // POD types are trivially move constructible.
 struct Movable {
   int a, b, c;
 };

test/clang-tidy/modernize-use-nullptr-basic.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s modernize-use-nullptr %t -- \
+// RUN: $(dirname %s)/check_clang_tidy.py %s modernize-use-nullptr %t -- \
 // RUN:   -std=c++98 -Wno-non-literal-null-conversion
-// REQUIRES: shell
 
 const unsigned int g_null = 0;
 #define NULL 0
 
 void test_assignment() {
   int *p1 = 0;
   // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: use nullptr [modernize-use-nullptr]
   // CHECK-FIXES: int *p1 = nullptr;

test/clang-tidy/modernize-use-nullptr.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s modernize-use-nullptr %t \
+// RUN: $(dirname %s)/check_clang_tidy.py %s modernize-use-nullptr %t \
 // RUN:   -config="{CheckOptions: [{key: modernize-use-nullptr.NullMacros, value: 'MY_NULL,NULL'}]}" \
 // RUN:   -- -std=c++11
-// REQUIRES: shell
 
 #define NULL 0
 
 namespace std {
 
 typedef decltype(nullptr) nullptr_t;
 
 } // namespace std

test/clang-tidy/readability-braces-around-statements-few-lines.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 4}]}" --
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 4}]}" --
 
 void do_something(const char *) {}
 
 bool cond(const char *) {
   return false;
 }
 
 void test() {

test/clang-tidy/readability-braces-around-statements-same-line.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 1}]}" --
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 1}]}" --
 
 void do_something(const char *) {}
 
 bool cond(const char *) {
   return false;
 }
 
 void test() {

test/clang-tidy/readability-braces-around-statements-single-line.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 2}]}" --
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-braces-around-statements %t -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 2}]}" --
 
 void do_something(const char *) {}
 
 bool cond(const char *) {
   return false;
 }
 
 void test() {

test/clang-tidy/readability-braces-around-statements.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-braces-around-statements %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-braces-around-statements %t
 
 void do_something(const char *) {}
 
 bool cond(const char *) {
   return false;
 }
 
 #define EMPTY_MACRO

test/clang-tidy/readability-container-size-empty.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-container-size-empty %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-container-size-empty %t
 
 namespace std {
 template <typename T> struct vector {
   vector() {}
   int size() const {}
   bool empty() const {}
 };
 }

test/clang-tidy/readability-else-after-return.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-else-after-return %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-else-after-return %t
 
 void f(int a) {
   if (a > 0)
     return;
   else // comment
 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: don't use else after return
 // CHECK-FIXES: {{^}}  // comment
     return;

test/clang-tidy/readability-function-size.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-function-size %t -config='{CheckOptions: [{key: readability-function-size.LineThreshold, value: 0}, {key: readability-function-size.StatementThreshold, value: 0}, {key: readability-function-size.BranchThreshold, value: 0}]}' -- -std=c++11
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-function-size %t -config='{CheckOptions: [{key: readability-function-size.LineThreshold, value: 0}, {key: readability-function-size.StatementThreshold, value: 0}, {key: readability-function-size.BranchThreshold, value: 0}]}' -- -std=c++11
 
 void foo1() {
 }
 
 void foo2() {;}
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'foo2' exceeds recommended size/complexity thresholds [readability-function-size]
 // CHECK-MESSAGES: :[[@LINE-2]]:6: note: 1 statements (threshold 0)
 

test/clang-tidy/readability-identifier-naming.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-identifier-naming %t \
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-identifier-naming %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: readability-identifier-naming.AbstractClassCase, value: CamelCase}, \
 // RUN:     {key: readability-identifier-naming.AbstractClassPrefix, value: 'A'}, \
 // RUN:     {key: readability-identifier-naming.ClassCase, value: CamelCase}, \
 // RUN:     {key: readability-identifier-naming.ClassPrefix, value: 'C'}, \
 // RUN:     {key: readability-identifier-naming.ClassConstantCase, value: CamelCase}, \
 // RUN:     {key: readability-identifier-naming.ClassConstantPrefix, value: 'k'}, \
 // RUN:     {key: readability-identifier-naming.ClassMemberCase, value: CamelCase}, \

 // RUN:     {key: readability-identifier-naming.UnionPrefix, value: 'U'}, \
 // RUN:     {key: readability-identifier-naming.UsingCase, value: lower_case}, \
 // RUN:     {key: readability-identifier-naming.ValueTemplateParameterCase, value: camelBack}, \
 // RUN:     {key: readability-identifier-naming.VariableCase, value: lower_case}, \
 // RUN:     {key: readability-identifier-naming.VirtualMethodCase, value: UPPER_CASE}, \
 // RUN:     {key: readability-identifier-naming.VirtualMethodPrefix, value: 'v_'}, \
 // RUN:     {key: readability-identifier-naming.IgnoreFailedSplit, value: 0} \
 // RUN:   ]}' -- -std=c++11 -fno-delayed-template-parsing
-// REQUIRES: shell
 
 // FIXME: There should be more test cases for checking that references to class
 // FIXME: name, declaration contexts, forward declarations, etc, are correctly
 // FIXME: checked and renamed
 
 namespace FOO_NS {
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: invalid case style for namespace 'FOO_NS' [readability-identifier-naming]
 // CHECK-FIXES: {{^}}namespace foo_ns {{{$}}

test/clang-tidy/readability-named-parameter.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-named-parameter %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-named-parameter %t
 
 void Method(char *) { /* */ }
 // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: all parameters should be named in a function
 // CHECK-FIXES: void Method(char * /*unused*/) { /* */ }
 void Method2(char *) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: all parameters should be named in a function
 // CHECK-FIXES: void Method2(char * /*unused*/) {}
 void Method3(char *, void *) {}

test/clang-tidy/readability-redundant-smartptr-get.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-redundant-smartptr-get %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-redundant-smartptr-get %t
 
 #define NULL __null
 
 namespace std {
 
 template <typename T>
 struct unique_ptr {
   T& operator*() const;

test/clang-tidy/readability-redundant-string-cstr.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-redundant-string-cstr %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-redundant-string-cstr %t
 
 namespace std {
 template <typename T>
 class allocator {};
 template <typename T>
 class char_traits {};
 template <typename C, typename T, typename A>
 struct basic_string {

test/clang-tidy/readability-shrink-to-fit.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-shrink-to-fit %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-shrink-to-fit %t
 
 namespace std {
 template <typename T> struct vector { void swap(vector &other); };
 }
 
 void f() {
   std::vector<int> v;
 

test/clang-tidy/readability-simplify-bool-expr-chained-conditional-assignment.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-simplify-boolean-expr %t -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalAssignment", value: 1}]}" --
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-simplify-boolean-expr %t -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalAssignment", value: 1}]}" --
 
 void chained_conditional_compound_assignment(int i) {
   bool b;
   if (i < 0) {
     b = true;
   } else if (i < 10) {
     b = false;
   } else if (i > 20) {

test/clang-tidy/readability-simplify-bool-expr-chained-conditional-return.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-simplify-boolean-expr %t -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalReturn", value: 1}]}" --
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-simplify-boolean-expr %t -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalReturn", value: 1}]}" --
 
 bool chained_conditional_compound_return(int i) {
   if (i < 0) {
     return true;
   } else if (i < 10) {
     return false;
   } else if (i > 20) {
     return true;

test/clang-tidy/readability-simplify-bool-expr.cpp

-// RUN: $(dirname %s)/check_clang_tidy.sh %s readability-simplify-boolean-expr %t
-// REQUIRES: shell
+// RUN: $(dirname %s)/check_clang_tidy.py %s readability-simplify-boolean-expr %t
 
 bool a1 = false;
 
 //=-=-=-=-=-=-= operator ==
 bool aa = false == a1;
 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant boolean literal supplied to boolean operator [readability-simplify-boolean-expr]
 // CHECK-FIXES: {{^bool aa = !a1;$}}
 bool ab = true == a1;