Run ClangTidy tests in all C++ language modes

[gribozavr]

Summary

I inspected every test and did one of the following:

• changed the test to run in all language modes,

• added a comment explaining why the test is only applicable in a certain mode,

• limited the test to language modes where it passes and added a FIXME to fix the checker or the test.

[JonasToth]

Wow, a lot of work!

I did not check all test files, but I saw that you explicitly enabled c++11,14,17 but not 98. Is there a reason for that? I think we should test that standard too.

[alexfh]

That's a quite impressive amount of work. Thanks! Looks good.

In D62125#1508113, @JonasToth wrote:

Wow, a lot of work!

I did not check all test files, but I saw that you explicitly enabled c++11,14,17 but not 98. Is there a reason for that? I think we should test that standard too.

Having seen the amount of work out into this I wouldn't demand c++98 coverage from Dimitri. It's a huge improvement already and c++98 coverage is a rather niche thing there days. I believe, someone with genuine need for C++98 support can work on that.

[gribozavr]

c++98 coverage is a rather niche thing there days. I believe, someone with genuine need for C++98 support can work on that.

+1, that's exactly the reason why I skipped 98. C++98 is 21 years old now (or 16 if you count from C++03). Most projects that build with a modern toolchain and care about code quality enough to run static analysis tools have migrated to C++11. Many ClangTidy checkers have not even been tested *ever* on 98, many (modernize-*) don't apply in 98.

We wouldn't refuse patches to annotate tests with C++98 support or fix bugs in C++98 mode, but I believe as far as ClangTidy is concerned C++98 is a niche use case, so I personally find it difficult to justify spending my time on it.

clang-tools-extra/test/clang-tidy/abseil-duration-unnecessary-conversion.cpp

-// RUN: %check_clang_tidy %s abseil-duration-unnecessary-conversion %t -- -- -I%S/Inputs
+// RUN: %check_clang_tidy -std=c++11,c++14 %s abseil-duration-unnecessary-conversion %t -- -- -I %S/Inputs
+// FIXME: Fix the checker to work in C++17 mode.
 
 #include "absl/time/time.h"
 
 void f() {
   absl::Duration d1, d2;
 
   // Floating point
   d2 = absl::Hours(absl::ToDoubleHours(d1));

clang-tools-extra/test/clang-tidy/abseil-faster-strsplit-delimiter.cpp

-// RUN: %check_clang_tidy %s abseil-faster-strsplit-delimiter %t
+// RUN: %check_clang_tidy -std=c++11,c++14 %s abseil-faster-strsplit-delimiter %t
+// FIXME: Fix the checker to work in C++17 mode.
 
 namespace absl {
 
 class string_view {
   public:
     string_view();
     string_view(const char *);
 };

clang-tools-extra/test/clang-tidy/abseil-str-cat-append.cpp

-// RUN: %check_clang_tidy %s abseil-str-cat-append %t -- -- -I%S -std=c++11
+// RUN: %check_clang_tidy %s abseil-str-cat-append %t
 
 typedef unsigned __INT16_TYPE__ char16;
 typedef unsigned __INT32_TYPE__ char32;
 typedef __SIZE_TYPE__ size;
 
 namespace std {
 template <typename T>
 class allocator {};

clang-tools-extra/test/clang-tidy/abseil-string-find-startswith.cpp

 // RUN: %check_clang_tidy %s abseil-string-find-startswith %t -- \
-// RUN:   -config="{CheckOptions: [{key: 'abseil-string-find-startswith.StringLikeClasses', value: '::std::basic_string;::basic_string'}]}" \
-// RUN:   -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: 'abseil-string-find-startswith.StringLikeClasses', value: '::std::basic_string;::basic_string'}]}"
 
 namespace std {
 template <typename T> class allocator {};
 template <typename T> class char_traits {};
 template <typename C, typename T = std::char_traits<C>,
           typename A = std::allocator<C>>
 struct basic_string {
   basic_string();

clang-tools-extra/test/clang-tidy/abseil-time-subtraction.cpp

-// RUN: %check_clang_tidy %s abseil-time-subtraction %t -- -- -I%S/Inputs
+// RUN: %check_clang_tidy -std=c++11,c++14 %s abseil-time-subtraction %t -- -- -I %S/Inputs
+// FIXME: Fix the checker to work in C++17 mode.
 
 #include "absl/time/time.h"
 
 void g(absl::Duration d);
 
 void f() {
   absl::Time t;
   int x, y;

clang-tools-extra/test/clang-tidy/abseil-upgrade-duration-conversions.cpp

-// RUN: %check_clang_tidy %s abseil-upgrade-duration-conversions %t -- -- -I%S/Inputs
+// RUN: %check_clang_tidy -std=c++11,c++14 %s abseil-upgrade-duration-conversions %t -- -- -I%S/Inputs
+// FIXME: Fix the checker to work in C++17 mode.
 
 using int64_t = long long;
 
 #include "absl/time/time.h"
 
 template <typename T> struct ConvertibleTo {
   operator T() const;
 };

clang-tools-extra/test/clang-tidy/bugprone-dangling-handle.cpp

-// RUN: %check_clang_tidy %s bugprone-dangling-handle %t -- \
+// RUN: %check_clang_tidy -std=c++11,c++14 %s bugprone-dangling-handle %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: bugprone-dangling-handle.HandleClasses, \
-// RUN:               value: 'std::basic_string_view; ::llvm::StringRef;'}]}" \
-// RUN:   -- -std=c++11
+// RUN:               value: 'std::basic_string_view; ::llvm::StringRef;'}]}"
+// FIXME: Fix the checker to work in C++17 mode.
 
 namespace std {
 
 template <typename T>
 class vector {
  public:
   using const_iterator = const T*;
   using iterator = T*;

clang-tools-extra/test/clang-tidy/bugprone-exception-escape.cpp

-// RUN: %check_clang_tidy %s bugprone-exception-escape %t -- -extra-arg=-std=c++11 -extra-arg=-fexceptions -config="{CheckOptions: [{key: bugprone-exception-escape.IgnoredExceptions, value: 'ignored1,ignored2'}, {key: bugprone-exception-escape.FunctionsThatShouldNotThrow, value: 'enabled1,enabled2,enabled3'}]}" --
+// RUN: %check_clang_tidy -std=c++11,c++14 %s bugprone-exception-escape %t -- \
+// RUN:     -config="{CheckOptions: [ \
+// RUN:         {key: bugprone-exception-escape.IgnoredExceptions, value: 'ignored1,ignored2'}, \
+// RUN:         {key: bugprone-exception-escape.FunctionsThatShouldNotThrow, value: 'enabled1,enabled2,enabled3'} \
+// RUN:     ]}" \
+// RUN:     -- -fexceptions
 
 struct throwing_destructor {
   ~throwing_destructor() {
     // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: an exception may be thrown in function '~throwing_destructor' which should not throw exceptions
     throw 1;
   }
 };
 

clang-tools-extra/test/clang-tidy/bugprone-forwarding-reference-overload.cpp

-// RUN: %check_clang_tidy %s bugprone-forwarding-reference-overload %t -- -- -std=c++14
+// RUN: %check_clang_tidy %s bugprone-forwarding-reference-overload %t
 
 namespace std {
 template <bool B, class T = void> struct enable_if { typedef T type; };
 
 template <class T> struct enable_if<true, T> { typedef T type; };
 
 template <bool B, class T = void>
 using enable_if_t = typename enable_if<B, T>::type;

clang-tools-extra/test/clang-tidy/bugprone-inaccurate-erase.cpp

-// RUN: %check_clang_tidy %s bugprone-inaccurate-erase %t
+// RUN: %check_clang_tidy -std=c++11,c++14 %s bugprone-inaccurate-erase %t
+// FIXME: Fix the checker to work in C++17 mode.
 
 namespace std {
 template <typename T> struct vec_iterator {
   T ptr;
   vec_iterator operator++(int);
 
   template <typename X>
   vec_iterator(const vec_iterator<X> &); // Omit enable_if<...>.

clang-tools-extra/test/clang-tidy/bugprone-move-forwarding-reference.cpp

-// RUN: %check_clang_tidy %s bugprone-move-forwarding-reference %t -- -- -std=c++14 -fno-delayed-template-parsing
+// RUN: %check_clang_tidy -std=c++14-or-later %s bugprone-move-forwarding-reference %t -- -- -fno-delayed-template-parsing
 
 namespace std {
 template <typename> struct remove_reference;
 
 template <typename _Tp> struct remove_reference { typedef _Tp type; };
 
 template <typename _Tp> struct remove_reference<_Tp &> { typedef _Tp type; };
 

clang-tools-extra/test/clang-tidy/bugprone-sizeof-container.cpp

-// RUN: %check_clang_tidy %s bugprone-sizeof-container %t -- -- -std=c++11 -target x86_64-unknown-unknown
+// RUN: %check_clang_tidy %s bugprone-sizeof-container %t -- -- -target x86_64-unknown-unknown
 
 namespace std {
 
 typedef unsigned int size_t;
 
 template <typename T>
 struct basic_string {
   size_t size() const;

clang-tools-extra/test/clang-tidy/cert-err34-c.cpp

-// RUN: %check_clang_tidy %s cert-err34-c %t -- -- -std=c++11
+// RUN: %check_clang_tidy %s cert-err34-c %t
 
 typedef void *             FILE;
 
 extern FILE *stdin;
 
 extern int fscanf(FILE * stream, const char * format, ...);
 extern int sscanf(const char * s, const char * format, ...);
 

clang-tools-extra/test/clang-tidy/cert-msc51-cpp.cpp

-// RUN: %check_clang_tidy %s cert-msc51-cpp %t -- -config="{CheckOptions: [{key: cert-msc51-cpp.DisallowedSeedTypes, value: 'some_type,time_t'}]}" -- -std=c++11
+// RUN: %check_clang_tidy %s cert-msc51-cpp %t -- \
+// RUN:     -config="{CheckOptions: [{key: cert-msc51-cpp.DisallowedSeedTypes, value: 'some_type,time_t'}]}"
 
 namespace std {
 
 void srand(int seed);
 
 template <class UIntType, UIntType a, UIntType c, UIntType m>
 struct linear_congruential_engine {
   linear_congruential_engine(int _ = 0);

clang-tools-extra/test/clang-tidy/cert-oop11-cpp.cpp

-// RUN: %check_clang_tidy %s cert-oop11-cpp %t -- -- -std=c++11
+// RUN: %check_clang_tidy %s cert-oop11-cpp %t
 
 struct B {
   B(B&&) noexcept = default;
 
   B(const B &) = default;
   B& operator=(const B&) = default;
   ~B() {}
 };

clang-tools-extra/test/clang-tidy/cert-setlongjmp.cpp

-// RUN: %check_clang_tidy %s cert-err52-cpp %t -- -- -std=c++11
+// RUN: %check_clang_tidy %s cert-err52-cpp %t
 
 typedef void *jmp_buf;
 extern int __setjmpimpl(jmp_buf);
 #define setjmp(x) __setjmpimpl(x)
 [[noreturn]] extern void longjmp(jmp_buf, int);
 
 namespace std {
 using ::jmp_buf;

clang-tools-extra/test/clang-tidy/cert-throw-exception-type.cpp

-// RUN: %check_clang_tidy %s cert-err60-cpp %t -- -- -std=c++11 -fcxx-exceptions
+// RUN: %check_clang_tidy -std=c++11,c++14 %s cert-err60-cpp %t -- -- -fcxx-exceptions
+// FIXME: Split off parts of this test that rely on dynamic exeption
+// specifications, and run this test in all language modes.
 
 struct S {};
 struct T : S {};
 struct U {
   U() = default;
   U(const U&) = default;
 };
 

clang-tools-extra/test/clang-tidy/check_clang_tidy.py

 import sys
 
 
 def write_file(file_name, text):
   with open(file_name, 'w') as f:
     f.write(text)
     f.truncate()
 
-def csv(string):
-  return string.split(',')
-
-def main():
-  parser = argparse.ArgumentParser()
-  parser.add_argument('-expect-clang-tidy-error', action='store_true')
-  parser.add_argument('-resource-dir')
-  parser.add_argument('-assume-filename')
-  parser.add_argument('input_file_name')
-  parser.add_argument('check_name')
-  parser.add_argument('temp_file_name')
-  parser.add_argument('-check-suffix', '-check-suffixes',
-                      default=[''], type=csv,
-                      help="comma-separated list of FileCheck suffixes")
-
-  args, extra_args = parser.parse_known_args()
 
+def run_test_once(args, extra_args):
   resource_dir = args.resource_dir
   assume_file_name = args.assume_filename
   input_file_name = args.input_file_name
   check_name = args.check_name
   temp_file_name = args.temp_file_name
   expect_clang_tidy_error = args.expect_clang_tidy_error
+  std = args.std
 
   file_name_with_extension = assume_file_name or input_file_name
   _, extension = os.path.splitext(file_name_with_extension)
   if extension not in ['.c', '.hpp', '.m', '.mm']:
     extension = '.cpp'
   temp_file_name = temp_file_name + extension
 
   clang_tidy_extra_args = extra_args
   clang_extra_args = []
   if '--' in extra_args:
     i = clang_tidy_extra_args.index('--')
     clang_extra_args = clang_tidy_extra_args[i + 1:]
     clang_tidy_extra_args = clang_tidy_extra_args[:i]
 
   # If the test does not specify a formatting style, force "none"; otherwise
   # autodetection logic can discover a ".clang-tidy" file that is not related to
   # the test.
   if not any(
       [arg.startswith('-format-style=') for arg in clang_tidy_extra_args]):
     clang_tidy_extra_args.append('-format-style=none')
 
-  if len(clang_extra_args) == 0:
-    if extension in ['.cpp', '.hpp', '.mm']:
-      clang_extra_args.append('--std=c++11')
-    if extension in ['.m', '.mm']:
-      clang_extra_args.extend(
-          ['-fobjc-abi-version=2', '-fobjc-arc'])
+    clang_extra_args = ['-fobjc-abi-version=2', '-fobjc-arc'] + clang_extra_args
+
+  if extension in ['.cpp', '.hpp', '.mm']:
+    clang_extra_args.append('-std=' + std)
 
   # Tests should not rely on STL being available, and instead provide mock
   # implementations of relevant APIs.
   clang_extra_args.append('-nostdinc++')
 
   if resource_dir is not None:
     clang_extra_args.append('-resource-dir=%s' % resource_dir)
 
try:
           ['FileCheck', '-input-file=' + notes_file, input_file_name,
            '-check-prefixes=' + ','.join(check_notes_prefixes),
            '-implicit-check-not={{note|warning|error}}:'],
           stderr=subprocess.STDOUT)
     except subprocess.CalledProcessError as e:
       print('FileCheck failed:\n' + e.output.decode())
       raise
 
+
+def expand_std(std):
+  if std == 'c++98-or-later':
+    return ['c++98', 'c++11', 'c++14', 'c++17', 'c++2a']
+  if std == 'c++11-or-later':
+    return ['c++11', 'c++14', 'c++17', 'c++2a']
+  if std == 'c++14-or-later':
+    return ['c++14', 'c++17', 'c++2a']
+  if std == 'c++17-or-later':
+    return ['c++17', 'c++2a']
+  if std == 'c++2a-or-later':
+    return ['c++2a']
+  return [std]
+
+
+def csv(string):
+  return string.split(',')
+
+
+def main():
+  parser = argparse.ArgumentParser()
+  parser.add_argument('-expect-clang-tidy-error', action='store_true')
+  parser.add_argument('-resource-dir')
+  parser.add_argument('-assume-filename')
+  parser.add_argument('input_file_name')
+  parser.add_argument('check_name')
+  parser.add_argument('temp_file_name')
+  parser.add_argument(
+      '-check-suffix',
+      '-check-suffixes',
+      default=[''],
+      type=csv,
+      help='comma-separated list of FileCheck suffixes')
+  parser.add_argument('-std', type=csv, default=['c++11-or-later'])
+
+  args, extra_args = parser.parse_known_args()
+
+  abbreviated_stds = args.std
+  for abbreviated_std in abbreviated_stds:
+    for std in expand_std(abbreviated_std):
+      args.std = std
+      run_test_once(args, extra_args)
+
+
 if __name__ == '__main__':
   main()

clang-tools-extra/test/clang-tidy/cppcoreguidelines-owning-memory-legacy-functions.cpp

 // RUN: %check_clang_tidy %s cppcoreguidelines-owning-memory %t \
 // RUN: -config='{CheckOptions: \
 // RUN:  [{key: cppcoreguidelines-owning-memory.LegacyResourceProducers, value: "::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile"}, \
 // RUN:   {key: cppcoreguidelines-owning-memory.LegacyResourceConsumers, value: "::free;::realloc;::freopen;::fclose"}]}' \
-// RUN: -- -std=c++11 -nostdlib -nostdinc++
+// RUN: -- -nostdlib -nostdinc++
 
 namespace gsl {
 template <class T>
 using owner = T;
 } // namespace gsl
 
 extern "C" {
 using size_t = decltype(sizeof(void*));

clang-tools-extra/test/clang-tidy/cppcoreguidelines-pro-bounds-constant-array-index-c++03.cpp

-// RUN: clang-tidy %s -checks=-*,cppcoreguidelines-pro-bounds-constant-array-index -- -std=c++03 | count 0
+// RUN: %check_clang_tidy -std=c++98-or-later %s cppcoreguidelines-pro-bounds-constant-array-index %t
 
 // Note: this test expects no diagnostics, but FileCheck cannot handle that,
 // hence the use of | count 0.
 template <int index> struct B {
   int get() {
     // The next line used to crash the check (in C++03 mode only).
     return x[index];
+    // CHECK-FIXES: return x[index];
   }
   int x[3];
 };

clang-tools-extra/test/clang-tidy/cppcoreguidelines-pro-bounds-constant-array-index-gslheader.cpp

-// RUN: %check_clang_tidy %s cppcoreguidelines-pro-bounds-constant-array-index %t -- -config='{CheckOptions: [{key: cppcoreguidelines-pro-bounds-constant-array-index.GslHeader, value: "dir1/gslheader.h"}]}' -- -std=c++11
+// RUN: %check_clang_tidy %s cppcoreguidelines-pro-bounds-constant-array-index %t -- \
+// RUN:     -config='{CheckOptions: [{key: cppcoreguidelines-pro-bounds-constant-array-index.GslHeader, value: "dir1/gslheader.h"}]}'
 // CHECK-FIXES: #include "dir1/gslheader.h"
 
 typedef __SIZE_TYPE__ size_t;
 
 namespace std {
   template<typename T, size_t N>
   struct array {
     T& operator[](size_t n);

clang-tools-extra/test/clang-tidy/cppcoreguidelines-pro-bounds-pointer-arithmetic-pr36489.cpp

-// RUN: %check_clang_tidy %s cppcoreguidelines-pro-bounds-pointer-arithmetic %t -- -- -std=c++14
+// RUN: %check_clang_tidy -std=c++14-or-later %s cppcoreguidelines-pro-bounds-pointer-arithmetic %t
 
 // Fix PR36489 and detect auto-deduced value correctly.
 char *getPtr();
 auto getPtrAuto() { return getPtr(); }
 decltype(getPtr()) getPtrDeclType();
 decltype(auto) getPtrDeclTypeAuto() { return getPtr(); }
 auto getPtrWithTrailingReturnType() -> char *;
 

clang-tools-extra/test/clang-tidy/cppcoreguidelines-pro-type-member-init-cxx2a.cpp

-// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init %t -- -- -std=c++2a -fno-delayed-template-parsing
+// RUN: %check_clang_tidy -std=c++2a %s cppcoreguidelines-pro-type-member-init %t -- -- -fno-delayed-template-parsing
 
 struct PositiveBitfieldMember {
   PositiveBitfieldMember() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these fields: F
   unsigned F : 5;
   // CHECK-FIXES: unsigned F : 5{};
 };
 

clang-tools-extra/test/clang-tidy/cppcoreguidelines-pro-type-member-init-cxx98.cpp

-// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init %t -- -- -std=c++98 -fno-delayed-template-parsing
+// RUN: %check_clang_tidy -std=c++98 %s cppcoreguidelines-pro-type-member-init %t -- -- -fno-delayed-template-parsing
 
 struct PositiveFieldBeforeConstructor {
   int F;
   PositiveFieldBeforeConstructor() /* some comment */ {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these fields: F
   // CHECK-FIXES: PositiveFieldBeforeConstructor() : F() /* some comment */ {}
 };
 

clang-tools-extra/test/clang-tidy/cppcoreguidelines-pro-type-member-init.cpp

-// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init %t -- -- -std=c++11 -fno-delayed-template-parsing
+// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s cppcoreguidelines-pro-type-member-init %t -- -- -fno-delayed-template-parsing
+// FIXME: Fix the checker to work in C++2a mode.
 
 struct PositiveFieldBeforeConstructor {
   int F;
   // CHECK-FIXES: int F{};
   PositiveFieldBeforeConstructor() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: constructor does not initialize these fields: F
   // CHECK-FIXES: PositiveFieldBeforeConstructor() {}
 };

clang-tools-extra/test/clang-tidy/cppcoreguidelines-special-member-functions-cxx-03.cpp

-// RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t -- -- -std=c++03
+// RUN: %check_clang_tidy -std=c++98 %s cppcoreguidelines-special-member-functions %t
 
 class DefinesDestructor {
   ~DefinesDestructor();
 };
 // CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesDestructor' defines a non-default destructor but does not define a copy constructor or a copy assignment operator [cppcoreguidelines-special-member-functions]
 
 class DefinesCopyConstructor {
   DefinesCopyConstructor(const DefinesCopyConstructor &);

clang-tools-extra/test/clang-tidy/expand-modular-headers-ppcallbacks.cpp

 // Sanity-check. Run without modules:
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/
-// RUN: %check_clang_tidy %s readability-identifier-naming %t/without-modules -- \
+// RUN: %check_clang_tidy -std=c++11 %s readability-identifier-naming %t/without-modules -- \
 // RUN:   -config="CheckOptions: [{ \
 // RUN:      key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \
 // RUN:   -header-filter=.* \
-// RUN:   -- -x c++ -std=c++11 -I%t/
+// RUN:   -- -I %t/
+//
+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/
+// RUN: %check_clang_tidy -std=c++17 %s readability-identifier-naming %t/without-modules -- \
+// RUN:   -config="CheckOptions: [{ \
+// RUN:      key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \
+// RUN:   -header-filter=.* \
+// RUN:   -- -I %t/
 //
 // Run clang-tidy on a file with modular includes:
 //
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/
-// RUN: %check_clang_tidy %s readability-identifier-naming %t/with-modules -- \
+// RUN: %check_clang_tidy -std=c++11 %s readability-identifier-naming %t/with-modules -- \
+// RUN:   -config="CheckOptions: [{ \
+// RUN:      key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \
+// RUN:   -header-filter=.* \
+// RUN:   -- -I %t/ \
+// RUN:   -fmodules -fimplicit-modules -fno-implicit-module-maps \
+// RUN:   -fmodule-map-file=%t/module.modulemap \
+// RUN:   -fmodules-cache-path=%t/module-cache/
+//
+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/
+// RUN: %check_clang_tidy -std=c++17 %s readability-identifier-naming %t/with-modules -- \
 // RUN:   -config="CheckOptions: [{ \
 // RUN:      key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \
 // RUN:   -header-filter=.* \
-// RUN:   -- -x c++ -std=c++11 -I%t/ \
+// RUN:   -- -I %t/ \
 // RUN:   -fmodules -fimplicit-modules -fno-implicit-module-maps \
 // RUN:   -fmodule-map-file=%t/module.modulemap \
 // RUN:   -fmodules-cache-path=%t/module-cache/
+// FIXME: Make the test work in all language modes.
 #include "c.h"
 
 // CHECK-MESSAGES: a.h:1:9: warning: invalid case style for macro definition 'a' [readability-identifier-naming]
 // CHECK-MESSAGES: a.h:1:9: note: FIX-IT applied suggested code changes
 // CHECK-MESSAGES: b.h:2:9: warning: invalid case style for macro definition 'b'
 // CHECK-MESSAGES: b.h:2:9: note: FIX-IT applied suggested code changes
 // CHECK-MESSAGES: c.h:2:9: warning: invalid case style for macro definition 'c'
 // CHECK-MESSAGES: c.h:2:9: note: FIX-IT applied suggested code changes
 
 #define m
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for macro definition 'm'
 // CHECK-MESSAGES: :[[@LINE-2]]:9: note: FIX-IT applied suggested code changes

clang-tools-extra/test/clang-tidy/fuchsia-restrict-system-includes-all.cpp

 // RUN: %check_clang_tidy %s fuchsia-restrict-system-includes %t \
-// RUN:   -- -config="{CheckOptions: [{key: fuchsia-restrict-system-includes.Includes, value: ''}]}" \
-// RUN:   -- -std=c++11 -I %S/Inputs/fuchsia-restrict-system-includes -isystem %S/Inputs/fuchsia-restrict-system-includes/system
+// RUN:     -- -config="{CheckOptions: [{key: fuchsia-restrict-system-includes.Includes, value: ''}]}" \
+// RUN:     -- -I %S/Inputs/fuchsia-restrict-system-includes -isystem %S/Inputs/fuchsia-restrict-system-includes/system
 
 #include <cstdlib.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include cstdlib.h not allowed
 #include <cstdarg.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include cstdarg.h not allowed
 #include <t.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include t.h not allowed

clang-tools-extra/test/clang-tidy/fuchsia-restrict-system-includes-glob.cpp

 // RUN: %check_clang_tidy %s fuchsia-restrict-system-includes %t \
-// RUN:   -- -config="{CheckOptions: [{key: fuchsia-restrict-system-includes.Includes, value: 'cstd*'}]}" \
-// RUN:   -- -std=c++11 -I %S/Inputs/fuchsia-restrict-system-includes -isystem %S/Inputs/fuchsia-restrict-system-includes/system
+// RUN:     -- -config="{CheckOptions: [{key: fuchsia-restrict-system-includes.Includes, value: 'cstd*'}]}" \
+// RUN:     -- -I %S/Inputs/fuchsia-restrict-system-includes -isystem %S/Inputs/fuchsia-restrict-system-includes/system
 
 #include <cstdlib.h>
 #include <cstdarg.h>
 #include <t.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include t.h not allowed
 // CHECK-FIXES-NOT: #include <t.h>

clang-tools-extra/test/clang-tidy/fuchsia-restrict-system-includes-headers.cpp

 // RUN: rm -rf %T/Headers
 // RUN: mkdir %T/Headers
 // RUN: cp -r %S/Inputs/fuchsia-restrict-system-includes %T/Headers/fuchsia-restrict-system-includes
-// RUN: %check_clang_tidy %s fuchsia-restrict-system-includes %t \
-// RUN:   -- -config="{CheckOptions: [{key: fuchsia-restrict-system-includes.Includes, value: 'transitive.h,s.h'}]}" \
+// RUN: %check_clang_tidy -std=c++11 %s fuchsia-restrict-system-includes %t \
+// RUN:   -- -config="{CheckOptions: [{key: fuchsia-restrict-system-includes.Includes, value: 'transitive.h,s.h'}]}" \
 // RUN:   -system-headers -header-filter=.* \
-// RUN:   -- -std=c++11 -I %T/Headers/fuchsia-restrict-system-includes -isystem %T/Headers/fuchsia-restrict-system-includes/system
+// RUN:   -- -I %T/Headers/fuchsia-restrict-system-includes -isystem %T/Headers/fuchsia-restrict-system-includes/system
 // RUN: FileCheck -input-file=%T/Headers/fuchsia-restrict-system-includes/transitive2.h %s -check-prefix=CHECK-FIXES
 // RUN: rm -rf %T/Headers
+// FIXME: Make the test work in all language modes.
 
 // transitive.h includes <r.h> and <t.h>
 #include <transitive.h>
 // CHECK-MESSAGES: :1:1: warning: system include r.h not allowed, transitively included from {{.*}}
 // CHECK-MESSAGES: :2:1: warning: system include t.h not allowed, transitively included from {{.*}}
 
 // transitive.h includes <s.h> and <t.h>
 #include "transitive2.h"
 // CHECK-MESSAGES: :2:1: warning: system include t.h not allowed, transitively included from {{.*}}
 // CHECK-FIXES-NOT: #include <t.h>
 
 int main() {
   // f() is declared in r.h
 }

clang-tools-extra/test/clang-tidy/fuchsia-restrict-system-includes.cpp

 // RUN: %check_clang_tidy %s fuchsia-restrict-system-includes %t \
-// RUN:   -- -config="{CheckOptions: [{key: fuchsia-restrict-system-includes.Includes, value: 's.h'}]}" \
-// RUN:   -- -std=c++11 -I %S/Inputs/fuchsia-restrict-system-includes -isystem %S/Inputs/fuchsia-restrict-system-includes/system
+// RUN:     -- -config="{CheckOptions: [{key: fuchsia-restrict-system-includes.Includes, value: 's.h'}]}" \
+// RUN:     -- -I %S/Inputs/fuchsia-restrict-system-includes -isystem %S/Inputs/fuchsia-restrict-system-includes/system
 
 #include "a.h"
 
 #include <s.h>
 #include <t.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include t.h not allowed
 // CHECK-FIXES-NOT: #include <t.h>
 

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

-// RUN: %check_clang_tidy %s google-readability-casting %t
+// RUN: %check_clang_tidy -std=c++11,c++14 %s google-readability-casting %t
+// FIXME: Fix the checker to work in C++17 mode.
 
 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) {

clang-tools-extra/test/clang-tidy/google-runtime-int-std.cpp

 // RUN: %check_clang_tidy %s google-runtime-int %t -- \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: google-runtime-int.UnsignedTypePrefix, value: "std::uint"}, \
 // RUN:     {key: google-runtime-int.SignedTypePrefix, value: "std::int"}, \
 // RUN:     {key: google-runtime-int.TypeSuffix, value: "_t"}, \
-// RUN:   ]}' -- -std=c++11
+// RUN:   ]}'
 
 long a();
 // CHECK-MESSAGES: [[@LINE-1]]:1: warning: consider replacing 'long' with 'std::int{{..}}_t'
 
 typedef unsigned long long uint64; // NOLINT
 
 long b(long = 1);
 // CHECK-MESSAGES: [[@LINE-1]]:1: warning: consider replacing 'long' with 'std::int{{..}}_t'

clang-tools-extra/test/clang-tidy/google-runtime-references.cpp

 // RUN: %check_clang_tidy %s google-runtime-references %t -- \
-// RUN:   -extra-arg="-std=c++11" \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: google-runtime-references.WhiteListTypes, \
-// RUN:               value: 'whitelist::A; whitelist::B'}]}" --
+// RUN:               value: 'whitelist::A; whitelist::B'}]}"
 
 int a;
 int &b = a;
 int *c;
 void f1(int a);
 void f2(int *b);
 void f3(const int &c);
 void f4(int const &d);

clang-tools-extra/test/clang-tidy/hicpp-signed-bitwise-standard-types.cpp

 // RUN: clang-tidy %s -checks='-*,hicpp-signed-bitwise' -- -std=c++11
+// FIXME: Make the test work in all language modes.
 
 #include "hicpp-signed-bitwise-standard-types.h"
 
 void pure_bitmask_types() {
   // std::locale::category
   int SResult = 0;
   std::locale::category C = std::locale::category::ctype;
 

clang-tools-extra/test/clang-tidy/hicpp-signed-bitwise.cpp

-// RUN: %check_clang_tidy %s hicpp-signed-bitwise %t -- -- -std=c++11 --target=x86_64-linux
+// RUN: %check_clang_tidy %s hicpp-signed-bitwise %t -- -- --target=x86_64-linux
 
 // These could cause false positives and should not be considered.
 struct StreamClass {
 };
 StreamClass &operator<<(StreamClass &os, unsigned int i) {
   return os;
 }
 StreamClass &operator<<(StreamClass &os, int i) {

clang-tools-extra/test/clang-tidy/misc-new-delete-overloads-sized-dealloc.cpp

-// RUN: %check_clang_tidy %s misc-new-delete-overloads %t -- -- -std=c++14 -fsized-deallocation
+// RUN: %check_clang_tidy %s misc-new-delete-overloads %t -- -- -fsized-deallocation
 
 typedef decltype(sizeof(int)) size_t;
 
 struct S {
   // CHECK-MESSAGES: :[[@LINE+1]]:8: warning: declaration of 'operator delete' has no matching declaration of 'operator new' at the same scope [misc-new-delete-overloads]
   void operator delete(void *ptr, size_t) noexcept; // not a placement delete
 };
 

clang-tools-extra/test/clang-tidy/misc-new-delete-overloads.cpp

-// RUN: %check_clang_tidy %s misc-new-delete-overloads %t -- -- -std=c++14
+// RUN: %check_clang_tidy %s misc-new-delete-overloads %t
 
 typedef decltype(sizeof(int)) size_t;
 
 struct S {
   // CHECK-MESSAGES: :[[@LINE+1]]:9: warning: declaration of 'operator new' has no matching declaration of 'operator delete' at the same scope [misc-new-delete-overloads]
   void *operator new(size_t size) noexcept;
   // CHECK-MESSAGES: :[[@LINE+1]]:9: warning: declaration of 'operator new[]' has no matching declaration of 'operator delete[]' at the same scope
   void *operator new[](size_t size) noexcept;

clang-tools-extra/test/clang-tidy/misc-redundant-expression.cpp

-// RUN: %check_clang_tidy %s misc-redundant-expression %t -- -- -std=c++11
+// RUN: %check_clang_tidy %s misc-redundant-expression %t
 
 typedef __INT64_TYPE__ I64;
 
 struct Point {
   int x;
   int y;
   int a[5];
 } P;

clang-tools-extra/test/clang-tidy/misc-throw-by-value-catch-by-reference.cpp

-// RUN: %check_clang_tidy %s misc-throw-by-value-catch-by-reference %t -- -- -std=c++11 -fcxx-exceptions
+// RUN: %check_clang_tidy %s misc-throw-by-value-catch-by-reference %t -- -- -fcxx-exceptions
 
 
 class logic_error {
 public:
   logic_error(const char *message) {}
 };
 
 typedef logic_error *logic_ptr;

clang-tools-extra/test/clang-tidy/misc-unconventional-assign-operator-cxx17.cpp

-// RUN: %check_clang_tidy %s misc-unconventional-assign-operator %t -- -- -std=c++17 -fno-delayed-template-parsing
+// RUN: %check_clang_tidy -std=c++14-or-later %s misc-unconventional-assign-operator %t -- -- -fno-delayed-template-parsing
 
 struct BadModifier {
   BadModifier& operator=(const BadModifier&) const;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: operator=() should not be marked 'const'
 };
 
 struct PR35468 {
   template<typename T> auto &operator=(const T &) {
     return *this;
   }
 };

clang-tools-extra/test/clang-tidy/misc-unconventional-assign-operator.cpp

-// RUN: %check_clang_tidy %s misc-unconventional-assign-operator %t -- -- -std=c++11 -isystem %S/Inputs/Headers -fno-delayed-template-parsing
+// RUN: %check_clang_tidy %s misc-unconventional-assign-operator %t -- -- -isystem %S/Inputs/Headers -fno-delayed-template-parsing
 
 namespace std {
 template <typename T>
 struct remove_reference { typedef T type; };
 template <typename T>
 struct remove_reference<T &> { typedef T type; };
 template <typename T>
 struct remove_reference<T &&> { typedef T type; };

clang-tools-extra/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: %check_clang_tidy %s misc-unused-parameters %t -- -header-filter='.*' -- -std=c++11 -fno-delayed-template-parsing
+// RUN: %check_clang_tidy -std=c++11 %s misc-unused-parameters %t -- -header-filter='.*' -- -fno-delayed-template-parsing
 // RUN: diff %T/header.h %T/header-fixed.h
+// FIXME: Make the test work in all language modes.
 
 #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]

clang-tools-extra/test/clang-tidy/modernize-avoid-bind.cpp

-// RUN: %check_clang_tidy %s modernize-avoid-bind %t -- -- -std=c++14
+// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-avoid-bind %t
 
 namespace std {
 inline namespace impl {
 template <class Fp, class... Arguments>
 class bind_rt {};
 
 template <class Fp, class... Arguments>
 bind_rt<Fp, Arguments...> bind(Fp &&, Arguments &&...);

clang-tools-extra/test/clang-tidy/modernize-concat-nested-namespaces.cpp

-// RUN: %check_clang_tidy %s modernize-concat-nested-namespaces %t -- -- -std=c++17
+// RUN: %check_clang_tidy -std=c++17-or-later %s modernize-concat-nested-namespaces %t
 
 namespace n1 {}
 
 namespace n2 {
 namespace n3 {
 void t();
 }
 namespace n4 {

clang-tools-extra/test/clang-tidy/modernize-deprecated-headers-cxx03.cpp

-// RUN: %check_clang_tidy %s modernize-deprecated-headers %t -- -extra-arg-before=-isystem%S/Inputs/modernize-deprecated-headers -- -std=c++03 -v
+// RUN: %check_clang_tidy -std=c++98 %s modernize-deprecated-headers %t -- -extra-arg-before=-isystem%S/Inputs/modernize-deprecated-headers
 
 #include <assert.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'assert.h'; consider using 'cassert' instead [modernize-deprecated-headers]
 // CHECK-FIXES: {{^}}#include <cassert>{{$}}
 #include <complex.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'complex.h'; consider using 'complex' instead
 // CHECK-FIXES: {{^}}#include <complex>{{$}}
 #include <ctype.h>

clang-tools-extra/test/clang-tidy/modernize-deprecated-headers-cxx11.cpp

-// RUN: %check_clang_tidy %s modernize-deprecated-headers %t -- -extra-arg-before=-isystem%S/Inputs/modernize-deprecated-headers -- -std=c++11 -v
+// RUN: %check_clang_tidy -std=c++11-or-later %s modernize-deprecated-headers %t -- -extra-arg-before=-isystem%S/Inputs/modernize-deprecated-headers
 
 #include <assert.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'assert.h'; consider using 'cassert' instead [modernize-deprecated-headers]
 // CHECK-FIXES: {{^}}#include <cassert>{{$}}
 #include <complex.h>
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: inclusion of deprecated C++ header 'complex.h'; consider using 'complex' instead
 // CHECK-FIXES: {{^}}#include <complex>{{$}}
 #include <ctype.h>

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

-// RUN: %check_clang_tidy %s modernize-loop-convert %t -- -- -std=c++11 -I %S/Inputs/modernize-loop-convert
+// RUN: %check_clang_tidy %s modernize-loop-convert %t -- -- -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};

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

 // RUN: %check_clang_tidy %s modernize-loop-convert %t -- \
 // RUN:   -config="{CheckOptions: [{key: modernize-loop-convert.NamingStyle, value: 'camelBack'}]}" \
-// RUN:   -- -std=c++11 -I %S/Inputs/modernize-loop-convert
+// RUN:   -- -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 const int n = 10;
 int arr[n];
 int nums[n];
 
 void naming() {

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

-// RUN: %check_clang_tidy %s modernize-loop-convert %t -- -- -std=c++11
+// RUN: %check_clang_tidy %s modernize-loop-convert %t
 
 struct Str {
   Str() = default;
   Str(const Str &) = default;
   void constMember(int) const;
   void nonConstMember(int);
   bool operator<(const Str &str) const;     // const operator.
   Str &operator=(const Str &str) = default; // non const operator.

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

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

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

 // RUN: %check_clang_tidy %s modernize-loop-convert %t -- \
 // RUN:   -config="{CheckOptions: [{key: modernize-loop-convert.NamingStyle, value: 'lower_case'}]}" \
-// RUN:   -- -std=c++11 -I %S/Inputs/modernize-loop-convert
+// RUN:   -- -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 const int n = 10;
 int arr[n];
 int nums[n];
 int nums_[n];
 

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

-// RUN: %check_clang_tidy %s modernize-loop-convert %t -- -- -std=c++11 -I %S/Inputs/modernize-loop-convert
+// RUN: %check_clang_tidy %s modernize-loop-convert %t -- -- -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 // CHECK-FIXES-NOT: for ({{.*[^:]:[^:].*}})
 // CHECK-MESSAGES-NOT: modernize-loop-convert
 
 namespace Negative {
 

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

 // RUN: %check_clang_tidy %s modernize-loop-convert %t -- \
 // RUN:   -config="{CheckOptions: [{key: modernize-loop-convert.NamingStyle, value: 'UPPER_CASE'}]}" \
-// RUN:   -- -std=c++11 -I %S/Inputs/modernize-loop-convert
+// RUN:   -- -I %S/Inputs/modernize-loop-convert
 
 #include "structures.h"
 
 const int N = 10;
 int ARR[N];
 int NUMS[N];
 int NUMS_[N];
 

clang-tools-extra/test/clang-tidy/modernize-make-shared-header.cpp

 // RUN: %check_clang_tidy %s modernize-make-shared %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:     [{key: modernize-make-shared.MakeSmartPtrFunction, \
 // RUN:       value: 'my::MakeShared'}, \
 // RUN:      {key: modernize-make-shared.MakeSmartPtrFunctionHeader, \
 // RUN:       value: 'make_shared_util.h'} \
 // RUN:     ]}" \
-// RUN:   -- -std=c++11 -I%S/Inputs/modernize-smart-ptr
+// RUN:   -- -I %S/Inputs/modernize-smart-ptr
 
 #include "shared_ptr.h"
 // CHECK-FIXES: #include "make_shared_util.h"
 
 void f() {
   std::shared_ptr<int> P1 = std::shared_ptr<int>(new int());
   // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use my::MakeShared instead
   // CHECK-FIXES: std::shared_ptr<int> P1 = my::MakeShared<int>();
 }

clang-tools-extra/test/clang-tidy/modernize-make-shared.cpp

-// RUN: %check_clang_tidy %s modernize-make-shared %t -- -- -std=c++11 \
-// RUN:   -I%S/Inputs/modernize-smart-ptr
+// RUN: %check_clang_tidy %s modernize-make-shared %t -- -- -I %S/Inputs/modernize-smart-ptr
 
 #include "shared_ptr.h"
 // CHECK-FIXES: #include <memory>
 
 struct Base {
   Base();
   Base(int, int);
 };

clang-tools-extra/test/clang-tidy/modernize-make-unique-cxx11.cpp

-// RUN: %check_clang_tidy %s modernize-make-unique %t -- -- -std=c++11 \
-// RUN:   -I%S/Inputs/modernize-smart-ptr
+// RUN: %check_clang_tidy -std=c++11 %s modernize-make-unique %t -- -- -I %S/Inputs/modernize-smart-ptr
 
 #include "unique_ptr.h"
 // CHECK-FIXES: #include "unique_ptr.h"
 
 void f() {
   auto my_ptr = std::unique_ptr<int>(new int(1));
   // CHECK-FIXES: auto my_ptr = std::unique_ptr<int>(new int(1));
 }

clang-tools-extra/test/clang-tidy/modernize-make-unique-cxx14.cpp

-// RUN: %check_clang_tidy %s modernize-make-unique %t -- -- -std=c++14 \
-// RUN:   -I%S/Inputs/modernize-smart-ptr
+// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-make-unique %t -- -- -I %S/Inputs/modernize-smart-ptr
 
 #include "unique_ptr.h"
 // CHECK-FIXES: #include <memory>
 
 void f() {
   auto my_ptr = std::unique_ptr<int>(new int(1));
   // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: use std::make_unique instead
   // CHECK-FIXES: auto my_ptr = std::make_unique<int>(1);
 }

clang-tools-extra/test/clang-tidy/modernize-make-unique-header.cpp

 // RUN: %check_clang_tidy %s modernize-make-unique %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:     [{key: modernize-make-unique.MakeSmartPtrFunction, \
 // RUN:       value: 'my::MakeUnique'}, \
 // RUN:      {key: modernize-make-unique.MakeSmartPtrFunctionHeader, \
 // RUN:       value: 'make_unique_util.h'} \
 // RUN:     ]}" \
-// RUN:   -- -std=c++11 -I%S/Inputs/modernize-smart-ptr
+// RUN:   -- -I %S/Inputs/modernize-smart-ptr
 
 #include "unique_ptr.h"
 // CHECK-FIXES: #include "make_unique_util.h"
 
 void f() {
   std::unique_ptr<int> P1 = std::unique_ptr<int>(new int());
   // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: use my::MakeUnique instead
   // CHECK-FIXES: std::unique_ptr<int> P1 = my::MakeUnique<int>();
 }

clang-tools-extra/test/clang-tidy/modernize-make-unique-macros.cpp

-// RUN: %check_clang_tidy %s modernize-make-unique %t -- \
+// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-make-unique %t -- \
 // RUN:   -config="{CheckOptions: [{key: modernize-make-unique.IgnoreMacros, value: 0}]}" \
-// RUN:   -- -std=c++14  -I%S/Inputs/modernize-smart-ptr
+// RUN:   -- -I %S/Inputs/modernize-smart-ptr
 
 #include "unique_ptr.h"
 
 class Foo {};
 class Bar {};
 #define DEFINE(...) __VA_ARGS__
 // CHECK-FIXES: {{^}}#define DEFINE(...) __VA_ARGS__{{$}}
 template<typename T>

clang-tools-extra/test/clang-tidy/modernize-make-unique.cpp

-// RUN: %check_clang_tidy %s modernize-make-unique %t -- -- -std=c++14 \
-// RUN:   -I%S/Inputs/modernize-smart-ptr
+// RUN: %check_clang_tidy -std=c++14 %s modernize-make-unique %t -- -- -I %S/Inputs/modernize-smart-ptr
+// FIXME: Fix the checker to work in C++17 mode.
 
 #include "unique_ptr.h"
 #include "initializer_list.h"
 // CHECK-FIXES: #include <memory>
 
 struct Base {
   Base();
   Base(int, int);

clang-tools-extra/test/clang-tidy/modernize-pass-by-value-header.cpp

 // RUN: cp %S/Inputs/modernize-pass-by-value/header.h %T/pass-by-value-header.h
 // RUN: clang-tidy %s -checks='-*,modernize-pass-by-value' -header-filter='.*' -fix -- -std=c++11 -I %T | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not="{{warning|error}}:"
 // RUN: FileCheck -input-file=%T/pass-by-value-header.h %s -check-prefix=CHECK-FIXES
+// FIXME: Make the test work in all language modes.
 
 #include "pass-by-value-header.h"
 // CHECK-MESSAGES: :8:5: warning: pass by value and use std::move [modernize-pass-by-value]
 // CHECK-FIXES: #include <utility>
 // CHECK-FIXES: A(ThreadId tid) : threadid(std::move(tid)) {}

clang-tools-extra/test/clang-tidy/modernize-pass-by-value-macro-header.cpp

-// RUN: %check_clang_tidy %s modernize-pass-by-value %t -- -- -std=c++11 -isystem %S/Inputs/Headers
+// RUN: %check_clang_tidy %s modernize-pass-by-value %t -- -- -isystem %S/Inputs/Headers
 
 // CHECK-FIXES: #include <utility>
 
 #define HEADER <./a.h>
 #include HEADER
 
 struct A {
   A(const A &) {}

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

-// RUN: %check_clang_tidy %s modernize-pass-by-value %t -- -- -std=c++11 -fno-delayed-template-parsing
+// RUN: %check_clang_tidy %s modernize-pass-by-value %t -- -- -fno-delayed-template-parsing
 
 namespace {
 // POD types are trivially move constructible.
 struct POD {
   int a, b, c;
 };
 
 struct Movable {

clang-tools-extra/test/clang-tidy/modernize-raw-string-literal-delimiter.cpp

-// RUN: %check_clang_tidy %s modernize-raw-string-literal %t -- -config='{CheckOptions: [{key: "modernize-raw-string-literal.DelimiterStem", value: "str"}, {key: modernize-raw-string-literal.ReplaceShorterLiterals, value: 1}]}' -- -std=c++11
+// RUN: %check_clang_tidy %s modernize-raw-string-literal %t -- -config='{CheckOptions: [{key: "modernize-raw-string-literal.DelimiterStem", value: "str"}, {key: modernize-raw-string-literal.ReplaceShorterLiterals, value: 1}]}'
 
 char const *const ContainsSentinel{"who\\ops)\""};
 // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: {{.*}} can be written as a raw string literal
 // CHECK-FIXES: {{^}}char const *const ContainsSentinel{R"str(who\ops)")str"};{{$}}
 
 //char const *const ContainsDelim{"whoops)\")lit\""};
 // CHECK-XMESSAGES: :[[@LINE-1]]:33: warning: {{.*}} can be written as a raw string literal
 // CHECK-XFIXES: {{^}}char const *const ContainsDelim{R"lit1(whoops)")lit")lit1"};{{$}}

clang-tools-extra/test/clang-tidy/modernize-raw-string-literal.cpp

-// RUN: %check_clang_tidy %s modernize-raw-string-literal %t -- -config="{CheckOptions: [{key: modernize-raw-string-literal.ReplaceShorterLiterals, value: 1}]}" -- -std=c++11
+// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s modernize-raw-string-literal %t -- -config="{CheckOptions: [{key: modernize-raw-string-literal.ReplaceShorterLiterals, value: 1}]}"
+// FIXME: Fix the checker to work in C++2a mode.
 
 char const *const BackSlash("goink\\frob");
 // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: escaped string literal can be written as a raw string literal [modernize-raw-string-literal]
 // CHECK-FIXES: {{^}}char const *const BackSlash(R"(goink\frob)");{{$}}
 
 char const *const PlainLiteral("plain literal");
 
 // Non-printable ASCII characters.

clang-tools-extra/test/clang-tidy/modernize-replace-auto-ptr.cpp

-// RUN: %check_clang_tidy %s modernize-replace-auto-ptr %t -- -- \
-// RUN:   -std=c++11 -I %S/Inputs/modernize-replace-auto-ptr
+// RUN: %check_clang_tidy %s modernize-replace-auto-ptr %t -- -- -I %S/Inputs/modernize-replace-auto-ptr
 
 // CHECK-FIXES: #include <utility>
 
 #include "memory.h"
 
 // Instrumentation for auto_ptr_ref test.
 struct Base {};
 struct Derived : Base {};

clang-tools-extra/test/clang-tidy/modernize-replace-random-shuffle.cpp

-// RUN: %check_clang_tidy %s modernize-replace-random-shuffle %t -- -- -std=c++11
+// RUN: %check_clang_tidy %s modernize-replace-random-shuffle %t
 
 //CHECK-FIXES: #include <random>
 
 namespace std {
 template <typename T> struct vec_iterator {
   T *ptr;
   vec_iterator operator++(int);
 };

clang-tools-extra/test/clang-tidy/modernize-return-braced-init-list.cpp

-// RUN: %check_clang_tidy %s modernize-return-braced-init-list %t -- -- -std=c++14
+// RUN: %check_clang_tidy -std=c++14 %s modernize-return-braced-init-list %t
+// FIXME: Fix the checker to work in C++17 mode.
 
 namespace std {
 typedef decltype(sizeof(int)) size_t;
 
 // libc++'s implementation
 template <class _E>
 class initializer_list {
   const _E *__begin_;

clang-tools-extra/test/clang-tidy/modernize-unary-static-assert.cpp

-// RUN: %check_clang_tidy %s modernize-unary-static-assert %t -- -- -std=c++1z
+// RUN: %check_clang_tidy -std=c++17-or-later %s modernize-unary-static-assert %t
 
 #define FOO static_assert(sizeof(a) <= 15, "");
 #define MSG ""
 
 void f_textless(int a) {
   static_assert(sizeof(a) <= 10, "");
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use unary 'static_assert' when the string literal is an empty string [modernize-unary-static-assert]
   // CHECK-FIXES: {{^}}  static_assert(sizeof(a) <= 10 );{{$}}

clang-tools-extra/test/clang-tidy/modernize-use-auto-cast-remove-stars.cpp

 // RUN: %check_clang_tidy %s modernize-use-auto %t -- \
 // RUN:   -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: '1'} , {key: modernize-use-auto.MinTypeNameLength, value: '0'}]}" \
-// RUN:   -- -std=c++11 -frtti
+// RUN:   -- -frtti
 
 struct A {
   virtual ~A() {}
 };
 
 struct B : public A {};
 
 struct C {};

clang-tools-extra/test/clang-tidy/modernize-use-auto-cast.cpp

 // RUN: %check_clang_tidy %s modernize-use-auto %t -- \
 // RUN:   -config="{CheckOptions: [{key: modernize-use-auto.MinTypeNameLength, value: '0'}]}" \
-// RUN:   -- -std=c++11 -I %S/Inputs/modernize-use-auto -frtti
+// RUN:   -- -I %S/Inputs/modernize-use-auto -frtti
 
 struct A {
   virtual ~A() {}
 };
 
 struct B : public A {};
 
 struct C {};

clang-tools-extra/test/clang-tidy/modernize-use-auto-iterator.cpp

-// RUN: %check_clang_tidy %s modernize-use-auto %t -- -- \
-// RUN:   -std=c++11 -I %S/Inputs/modernize-use-auto
+// RUN: %check_clang_tidy -std=c++11,c++14 %s modernize-use-auto %t -- -- -I %S/Inputs/modernize-use-auto
+// FIXME: Fix the checker to work in C++17 mode.
 
 #include "containers.h"
 
 void f_array() {
   std::array<int, 4> C;
   std::array<int, 4>::iterator ArrayI1 = C.begin();
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use auto when declaring iterators [modernize-use-auto]
   // CHECK-FIXES: auto ArrayI1 = C.begin();

clang-tools-extra/test/clang-tidy/modernize-use-auto-min-type-name-length.cpp

-// RUN: %check_clang_tidy -check-suffix=0-0 %s modernize-use-auto %t  -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 0}, {key: modernize-use-auto.MinTypeNameLength, value: 0}]}" -- --std=c++11 -frtti
-// RUN: %check_clang_tidy -check-suffix=0-8 %s modernize-use-auto %t  -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 0}, {key: modernize-use-auto.MinTypeNameLength, value: 8}]}" -- --std=c++11 -frtti
-// RUN: %check_clang_tidy -check-suffix=1-0 %s modernize-use-auto %t  -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 1}, {key: modernize-use-auto.MinTypeNameLength, value: 0}]}" -- --std=c++11 -frtti
-// RUN: %check_clang_tidy -check-suffix=1-8 %s modernize-use-auto %t  -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 1}, {key: modernize-use-auto.MinTypeNameLength, value: 8}]}" -- --std=c++11 -frtti
+// RUN: %check_clang_tidy -check-suffix=0-0 %s modernize-use-auto %t  -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 0}, {key: modernize-use-auto.MinTypeNameLength, value: 0}]}" -- -frtti
+// RUN: %check_clang_tidy -check-suffix=0-8 %s modernize-use-auto %t  -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 0}, {key: modernize-use-auto.MinTypeNameLength, value: 8}]}" -- -frtti
+// RUN: %check_clang_tidy -check-suffix=1-0 %s modernize-use-auto %t  -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 1}, {key: modernize-use-auto.MinTypeNameLength, value: 0}]}" -- -frtti
+// RUN: %check_clang_tidy -check-suffix=1-8 %s modernize-use-auto %t  -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 1}, {key: modernize-use-auto.MinTypeNameLength, value: 8}]}" -- -frtti
 
 template <class T> extern T foo();
 template <class T> struct P {  explicit P(T t) : t_(t) {}  T t_;};
 template <class T> P<T> *foo_ptr();
 template <class T> P<T> &foo_ref();
 
 int bar() {
   {

clang-tools-extra/test/clang-tidy/modernize-use-auto-new-remove-stars.cpp

 // RUN: %check_clang_tidy %s modernize-use-auto %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: '1'}, {key: modernize-use-auto.MinTypeNameLength, value: '0'}]}" \
-// RUN:   -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: '1'}, {key: modernize-use-auto.MinTypeNameLength, value: '0'}]}"
 
 class MyType {};
 
 class MyDerivedType : public MyType {};
 
 // FIXME: the replacement sometimes results in two consecutive spaces after
 // the word 'auto' (due to the presence of spaces at both sides of '*').
 void auto_new() {

clang-tools-extra/test/clang-tidy/modernize-use-auto-new.cpp

 // RUN: %check_clang_tidy %s modernize-use-auto %t -- \
 // RUN:   -config="{CheckOptions: [{key: modernize-use-auto.MinTypeNameLength, value: '0'}]}" \
-// RUN:   -- -std=c++11 -frtti
+// RUN:   -- -frtti
 
 class MyType {};
 
 class MyDerivedType : public MyType {};
 
 // FIXME: the replacement sometimes results in two consecutive spaces after
 // the word 'auto' (due to the presence of spaces at both sides of '*').
 void auto_new() {

clang-tools-extra/test/clang-tidy/modernize-use-bool-literals-ignore-macros.cpp

 // RUN: %check_clang_tidy %s modernize-use-bool-literals %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: modernize-use-bool-literals.IgnoreMacros, \
-// RUN:               value: 1}]}" \
-// RUN:   -- -std=c++11
+// RUN:               value: 1}]}"
 
 bool IntToTrue = 1;
 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: converting integer literal to bool, use bool literal instead [modernize-use-bool-literals]
 // CHECK-FIXES: {{^}}bool IntToTrue = true;{{$}}
 
 bool IntToFalse(0);
 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: converting integer literal to bool
 // CHECK-FIXES: {{^}}bool IntToFalse(false);{{$}}

clang-tools-extra/test/clang-tidy/modernize-use-bool-literals.cpp

 // RUN: %check_clang_tidy %s modernize-use-bool-literals %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: modernize-use-bool-literals.IgnoreMacros, \
-// RUN:               value: 0}]}" \
-// RUN:   -- -std=c++11
+// RUN:               value: 0}]}"
 
 bool IntToTrue = 1;
 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: converting integer literal to bool, use bool literal instead [modernize-use-bool-literals]
 // CHECK-FIXES: {{^}}bool IntToTrue = true;{{$}}
 
 bool IntToFalse(0);
 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: converting integer literal to bool
 // CHECK-FIXES: {{^}}bool IntToFalse(false);{{$}}

clang-tools-extra/test/clang-tidy/modernize-use-default-member-init-assignment.cpp

 // RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- \
-// RUN: -config="{CheckOptions: [{key: modernize-use-default-member-init.UseAssignment, value: 1}]}" -- -std=c++11
+// RUN: -config="{CheckOptions: [{key: modernize-use-default-member-init.UseAssignment, value: 1}]}"
 
 struct S {
 };
 
 struct PositiveValueChar {
   PositiveValueChar() : c0(), c1()/*, c2(), c3()*/ {}
   // CHECK-FIXES: PositiveValueChar()  {}
   const char c0;

clang-tools-extra/test/clang-tidy/modernize-use-default-member-init-bitfield.cpp

-// RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- -- -std=c++2a
+// RUN: %check_clang_tidy -std=c++2a-or-later %s modernize-use-default-member-init %t
 
 struct PositiveBitField
 {
   PositiveBitField() : i(6) {}
   // CHECK-FIXES: PositiveBitField()  {}
   int i : 5;
   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: use default member initializer for 'i' [modernize-use-default-member-init]
   // CHECK-FIXES: int i : 5{6};
 };

clang-tools-extra/test/clang-tidy/modernize-use-default-member-init-macros.cpp

 // RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-default-member-init.IgnoreMacros, value: 0}]}" \
-// RUN:   -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: modernize-use-default-member-init.IgnoreMacros, value: 0}]}"
 
 #define MACRO() \
   struct S { \
     void *P; \
     S() : P(nullptr) {} \
   };
 
 MACRO();
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use default member initializer for 'P'
 
 struct S2 {
   void *P;
   // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use default member initializer for 'P'
   S2() : P(nullptr) {}
 };

clang-tools-extra/test/clang-tidy/modernize-use-default-member-init.cpp

-// RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- -- -std=c++11
+// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s modernize-use-default-member-init %t
+// FIXME: Fix the checker to work in C++2a mode.
 
 struct S {
 };
 
 struct PositiveValueChar {
   PositiveValueChar() : c0(), c1()/*, c2(), c3()*/ {}
   // CHECK-FIXES: PositiveValueChar()  {}
   const char c0;

clang-tools-extra/test/clang-tidy/modernize-use-emplace-ignore-implicit-constructors.cpp

 // RUN: %check_clang_tidy %s modernize-use-emplace %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: modernize-use-emplace.IgnoreImplicitConstructors, \
 // RUN:               value: 1}] \
-// RUN:             }" -- -std=c++11
+// RUN:             }"
 
 namespace std {
 template <typename>
 class initializer_list
 {
 public:
   initializer_list() noexcept {}
 };

clang-tools-extra/test/clang-tidy/modernize-use-emplace.cpp

 // RUN: %check_clang_tidy %s modernize-use-emplace %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: modernize-use-emplace.ContainersWithPushBack, \
 // RUN:               value: '::std::vector; ::std::list; ::std::deque; llvm::LikeASmallVector'}, \
 // RUN:              {key: modernize-use-emplace.TupleTypes, \
 // RUN:               value: '::std::pair; std::tuple; ::test::Single'}, \
 // RUN:              {key: modernize-use-emplace.TupleMakeFunctions, \
 // RUN:               value: '::std::make_pair; ::std::make_tuple; ::test::MakeSingle'}] \
-// RUN:             }" -- -std=c++11
+// RUN:             }"
 
 namespace std {
 template <typename>
 class initializer_list
 {
 public:
   initializer_list() noexcept {}
 };

clang-tools-extra/test/clang-tidy/modernize-use-equals-default-copy.cpp

 // RUN: %check_clang_tidy %s modernize-use-equals-default %t -- \
 // RUN:   -config="{CheckOptions: [{key: modernize-use-equals-default.IgnoreMacros, value: 0}]}" \
-// RUN:   -- -std=c++11 -fno-delayed-template-parsing -fexceptions
+// RUN:   -- -fno-delayed-template-parsing -fexceptions
 
 // Out of line definition.
 struct OL {
   OL(const OL &);
   OL &operator=(const OL &);
   int Field;
 };
 OL::OL(const OL &Other) : Field(Other.Field) {}

clang-tools-extra/test/clang-tidy/modernize-use-equals-default-delayed.cpp

 // RUN: clang-tidy %s -checks=-*,modernize-use-equals-default -- -std=c++11 -fdelayed-template-parsing -fexceptions | count 0
 // Note: this test expects no diagnostics, but FileCheck cannot handle that,
 // hence the use of | count 0.
+// FIXME: Make the test work in all language modes.
 
 template <typename Ty>
 struct S {
   S<Ty>& operator=(const S<Ty>&) { return *this; }
 };

clang-tools-extra/test/clang-tidy/modernize-use-equals-default-macros.cpp

 // RUN: %check_clang_tidy %s modernize-use-equals-default %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-equals-default.IgnoreMacros, value: 0}]}" \
-// RUN:   -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: modernize-use-equals-default.IgnoreMacros, value: 0}]}"
 
 #define STRUCT_WITH_DEFAULT(_base, _type) \
   struct _type {                          \
     _type() {}                            \
     _base value;                          \
   };
 
 STRUCT_WITH_DEFAULT(unsigned char, InMacro)
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use '= default' to define a trivial default constructor
 // CHECK-MESSAGES: :[[@LINE-6]]:13: note:

clang-tools-extra/test/clang-tidy/modernize-use-equals-default.cpp

-// RUN: %check_clang_tidy %s modernize-use-equals-default %t -- -- -std=c++11 -fno-delayed-template-parsing  -fexceptions
+// RUN: %check_clang_tidy %s modernize-use-equals-default %t -- -- -fno-delayed-template-parsing -fexceptions
 
 // Out of line definition.
 class OL {
 public:
   OL();
   ~OL();
 };
 

clang-tools-extra/test/clang-tidy/modernize-use-equals-delete-macros.cpp

 // RUN: %check_clang_tidy %s modernize-use-equals-delete %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-equals-delete.IgnoreMacros, value: 0}]}" \
-// RUN:   -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: modernize-use-equals-delete.IgnoreMacros, value: 0}]}"
 
 #define MACRO(type) void operator=(type const &)
 class C {
 private:
   MACRO(C);
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= delete' to prohibit calling of a special member function
 };

clang-tools-extra/test/clang-tidy/modernize-use-nodiscard-clang-unused.cpp

 // RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: '[[clang::warn_unused_result]]'}]}" \
-// RUN: -- -std=c++11 
+// RUN:   -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: '[[clang::warn_unused_result]]'}]}"
 
 class Foo
 {
 public:
     bool f1() const;
     // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: function 'f1' should be marked {{\[\[clang::warn_unused_result\]\]}} [modernize-use-nodiscard]
     // CHECK-FIXES: {{\[\[clang::warn_unused_result\]\]}} bool f1() const;
 

clang-tools-extra/test/clang-tidy/modernize-use-nodiscard-cxx11.cpp

 // RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: '__attribute__((warn_unused_result))'}]}" \
-// RUN: -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: '__attribute__((warn_unused_result))'}]}"
 
 class Foo
 {
 public:
     bool f1() const;
     // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: function 'f1' should be marked __attribute__((warn_unused_result)) [modernize-use-nodiscard]
     // CHECK-FIXES: __attribute__((warn_unused_result)) bool f1() const;
 

clang-tools-extra/test/clang-tidy/modernize-use-nodiscard-gcc-unused.cpp

 // RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: '[[gcc::warn_unused_result]]'}]}" \
-// RUN: -- -std=c++11 
+// RUN:   -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: '[[gcc::warn_unused_result]]'}]}"
 
 class Foo
 {
 public:
     bool f1() const;
     // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: function 'f1' should be marked {{\[\[gcc::warn_unused_result\]\]}} [modernize-use-nodiscard]
     // CHECK-FIXES: {{\[\[gcc::warn_unused_result\]\]}} bool f1() const;
 

clang-tools-extra/test/clang-tidy/modernize-use-nodiscard-no-macro-inscope-cxx11.cpp

 // RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: 'CUSTOM_NO_DISCARD'}]}" -- -std=c++11 
+// RUN:   -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: 'CUSTOM_NO_DISCARD'}]}"
 
 // As if the macro was not defined.
 // #define CUSTOM_NO_DISCARD __attribute_((warn_unused_result))
 
 class Foo
 {
 public:
     bool f1() const;
     // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: function 'f1' should be marked CUSTOM_NO_DISCARD [modernize-use-nodiscard]
 };
 

clang-tools-extra/test/clang-tidy/modernize-use-nodiscard-no-macro.cpp

-// RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- -- -std=c++17 
+// RUN: %check_clang_tidy -std=c++17-or-later %s modernize-use-nodiscard %t
 
 class Foo
 {
 public:
     bool f1() const;
     // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: function 'f1' should be marked {{\[\[nodiscard\]\]}} [modernize-use-nodiscard]
     // CHECK-FIXES: {{\[\[nodiscard\]\]}} bool f1() const;
 

clang-tools-extra/test/clang-tidy/modernize-use-noexcept-macro.cpp

-// RUN: %check_clang_tidy %s modernize-use-noexcept %t -- \
+// RUN: %check_clang_tidy -std=c++11,c++14 %s modernize-use-noexcept %t -- \
 // RUN:   -config="{CheckOptions: [{key: modernize-use-noexcept.ReplacementString, value: 'NOEXCEPT'}]}" \
-// RUN:   -- -std=c++11 -fexceptions
+// RUN:   -- -fexceptions
+// This test is not run in C++17 or later because dynamic exception
+// specifications were removed in C++17.
 
 // Example definition of NOEXCEPT -- simplified test to see if noexcept is supported.
 #if (__has_feature(cxx_noexcept))
 #define NOEXCEPT noexcept
 #else
 #define NOEXCEPT throw()
 #endif
 

clang-tools-extra/test/clang-tidy/modernize-use-noexcept-opt.cpp

-// RUN: %check_clang_tidy %s modernize-use-noexcept %t -- \
+// RUN: %check_clang_tidy -std=c++11,c++14 %s modernize-use-noexcept %t -- \
 // RUN:   -config="{CheckOptions: [{key: modernize-use-noexcept.UseNoexceptFalse, value: 0}]}" \
-// RUN:   -- -std=c++11 -fexceptions
+// RUN:   -- -fexceptions
+// This test is not run in C++17 or later because dynamic exception
+// specifications were removed in C++17.
 
 class A {};
 class B {};
 
 void foo() throw();
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
 // CHECK-FIXES: void foo() noexcept;
 

clang-tools-extra/test/clang-tidy/modernize-use-noexcept.cpp

-// RUN: %check_clang_tidy %s modernize-use-noexcept %t -- \
-// RUN:   -- -std=c++11 -fexceptions
+// RUN: %check_clang_tidy -std=c++11,c++14 %s modernize-use-noexcept %t -- -- -fexceptions
+// This test is not run in C++17 or later because dynamic exception
+// specifications were removed in C++17.
 
 class A {};
 class B {};
 
 void foo() throw();
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: dynamic exception specification 'throw()' is deprecated; consider using 'noexcept' instead [modernize-use-noexcept]
 // CHECK-FIXES: void foo() noexcept;
 

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

-// RUN: %check_clang_tidy %s modernize-use-nullptr %t -- -- \
-// RUN:   -std=c++98 -Wno-non-literal-null-conversion
+// RUN: %check_clang_tidy -std=c++98 %s modernize-use-nullptr %t -- -- -Wno-non-literal-null-conversion
 //
 // Some parts of the test (e.g. assignment of `const int` to `int *`) fail in
 // C++11, so we need to run the test in C++98 mode.
+//
+// FIXME: Make the test work in all language modes.
 
 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;

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

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

clang-tools-extra/test/clang-tidy/modernize-use-override-cxx98.cpp

-// RUN: %check_clang_tidy %s modernize-use-override %t -- -- -std=c++98
+// RUN: %check_clang_tidy -std=c++98 %s modernize-use-override %t
 
 struct Base {
   virtual ~Base() {}
   virtual void a();
   virtual void b();
 };
 
 struct SimpleCases : public Base {

clang-tools-extra/test/clang-tidy/modernize-use-override-ms.cpp

-// RUN: %check_clang_tidy %s modernize-use-override %t -- -- -fms-extensions -std=c++11
+// RUN: %check_clang_tidy %s modernize-use-override %t -- -- -fms-extensions
 
 // This test is designed to test ms-extension __declspec(dllexport) attributes.
 #define EXPORT __declspec(dllexport)
 
 class Base {
   virtual EXPORT void a();
 };
 

clang-tools-extra/test/clang-tidy/modernize-use-override-no-destructors.cpp

 // RUN: %check_clang_tidy %s modernize-use-override %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-override.IgnoreDestructors, value: 1}]}" \
-// RUN: -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: modernize-use-override.IgnoreDestructors, value: 1}]}"
 
 struct Base {
   virtual ~Base();
   virtual void f();
 };
 
 struct Simple : public Base {
   virtual ~Simple();
   // CHECK-MESSAGES-NOT: warning:
   virtual void f();
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using
   // CHECK-FIXES: {{^}}  void f() override;
 };

clang-tools-extra/test/clang-tidy/modernize-use-override-with-macro.cpp

 // RUN: %check_clang_tidy %s modernize-use-override %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-override.OverrideSpelling, value: 'OVERRIDE'},{key: modernize-use-override.FinalSpelling, value: 'FINAL'}]}" \
-// RUN: -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: modernize-use-override.OverrideSpelling, value: 'OVERRIDE'},{key: modernize-use-override.FinalSpelling, value: 'FINAL'}]}"
 
 #define ABSTRACT = 0
 
 #define OVERRIDE override
 #define FINAL final
 #define VIRTUAL virtual
 #define NOT_VIRTUAL
 #define NOT_OVERRIDE

clang-tools-extra/test/clang-tidy/modernize-use-override-with-no-macro-inscope.cpp

 // RUN: %check_clang_tidy %s modernize-use-override %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-override.OverrideSpelling, value: 'CUSTOM_OVERRIDE'},{key: modernize-use-override.FinalSpelling, value: 'CUSTOM_FINAL'}]}" \
-// RUN: -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: modernize-use-override.OverrideSpelling, value: 'CUSTOM_OVERRIDE'},{key: modernize-use-override.FinalSpelling, value: 'CUSTOM_FINAL'}]}"
 
 // As if the macro was not defined.
 //#define CUSTOM_OVERRIDE override
 //#define CUSTOM_FINAL override
 
 struct Base {
   virtual ~Base() {}
   virtual void a();

clang-tools-extra/test/clang-tidy/modernize-use-override.cpp

-// RUN: %check_clang_tidy %s modernize-use-override %t -- -- -std=c++11 -fexceptions
+// RUN: %check_clang_tidy %s modernize-use-override %t -- -- -fexceptions
 
 #define ABSTRACT = 0
 
 #define OVERRIDE override
 #define VIRTUAL virtual
 #define NOT_VIRTUAL
 #define NOT_OVERRIDE
 

clang-tools-extra/test/clang-tidy/modernize-use-trailing-return-type.cpp

-// RUN: %check_clang_tidy %s modernize-use-trailing-return-type %t -- -- --std=c++14 -fdeclspec -fexceptions
+// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-use-trailing-return-type %t -- -- -fdeclspec -fexceptions
 
 namespace std {
     template <typename T>
     class vector;
 
     template <typename T, int N>
     class array;
 

clang-tools-extra/test/clang-tidy/modernize-use-transparent-functors.cpp

-// RUN: %check_clang_tidy %s modernize-use-transparent-functors %t -- -- -std=c++14
+// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-use-transparent-functors %t
 
 namespace std {
 template<class T>
 struct remove_reference;
 
 template <class T>
 constexpr T &&forward(typename std::remove_reference<T>::type &t);
 

clang-tools-extra/test/clang-tidy/modernize-use-uncaught-exceptions.cpp

-// RUN: %check_clang_tidy %s modernize-use-uncaught-exceptions %t -- -- -std=c++1z
+// RUN: %check_clang_tidy -std=c++17-or-later %s modernize-use-uncaught-exceptions %t
+
 #define MACRO std::uncaught_exception
 // CHECK-FIXES: #define MACRO std::uncaught_exception
 
 bool uncaught_exception() {
   return 0;
 }
 
 namespace std {

clang-tools-extra/test/clang-tidy/modernize-use-using-macros.cpp

 // RUN: %check_clang_tidy %s modernize-use-using %t -- \
-// RUN:   -config="{CheckOptions: [{key: modernize-use-using.IgnoreMacros, value: 0}]}" \
-// RUN:   -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: modernize-use-using.IgnoreMacros, value: 0}]}"
 
 #define CODE typedef int INT
 
 CODE;
 // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use 'using' instead of 'typedef'
 // CHECK-FIXES: #define CODE typedef int INT
 // CHECK-FIXES: CODE;
 

clang-tools-extra/test/clang-tidy/objc-no-arc-or-properties.m

-// RUN: %check_clang_tidy %s bugprone-suspicious-semicolon %t -- -- -fno-objc-arc -fobjc-abi-version=1
+// RUN: %check_clang_tidy -std=c99 %s bugprone-suspicious-semicolon %t -- -- -fno-objc-arc -fobjc-abi-version=1
 
 // This test ensures check_clang_tidy.py allows disabling Objective-C ARC and
 // Objective-C 2.0 via passing arguments after -- on the command line.
 //
 // (We could include a test which doesn't pass any arguments after --
 // to check if ARC and ObjC 2.0 are disabled by default, but that test
 // could change behavior based on the default Objective-C runtime for
 // the platform, which would make this test flaky.)

clang-tools-extra/test/clang-tidy/openmp-use-default-none.cpp

-// RUN: %check_clang_tidy %s openmp-use-default-none %t -- -- -x c++ -fopenmp=libomp -fopenmp-version=40
-// RUN: %check_clang_tidy %s openmp-use-default-none %t -- -- -x c   -fopenmp=libomp -fopenmp-version=40
+// RUN: %check_clang_tidy %s openmp-use-default-none %t -- -- -fopenmp=libomp -fopenmp-version=40
+// RUN: %check_clang_tidy -std=c11 %s openmp-use-default-none %t -- -- -x c -fopenmp=libomp -fopenmp-version=40
 
 //----------------------------------------------------------------------------//
 // Null cases.
 //----------------------------------------------------------------------------//
 
 // 'for' directive can not have 'default' clause, no diagnostics.
 void n0(const int a) {
 #pragma omp for

clang-tools-extra/test/clang-tidy/performance-for-range-copy-allowed-types.cpp

-// RUN: %check_clang_tidy %s performance-for-range-copy %t -- -config="{CheckOptions: [{key: performance-for-range-copy.AllowedTypes, value: '[Pp]ointer$;[Pp]tr$;[Rr]ef(erence)?$'}]}" -- -std=c++11 -fno-delayed-template-parsing
+// RUN: %check_clang_tidy %s performance-for-range-copy %t -- \
+// RUN:     -config="{CheckOptions: [{key: performance-for-range-copy.AllowedTypes, value: '[Pp]ointer$;[Pp]tr$;[Rr]ef(erence)?$'}]}" \
+// RUN:     -- -fno-delayed-template-parsing
 
 template <typename T>
 struct Iterator {
   void operator++() {}
   const T& operator*() {
     static T* TT = new T();
     return *TT;
   }

clang-tools-extra/test/clang-tidy/performance-for-range-copy-warn-on-all-auto-copies.cpp

-// RUN: %check_clang_tidy %s performance-for-range-copy %t -config="{CheckOptions: [{key: "performance-for-range-copy.WarnOnAllAutoCopies", value: 1}]}" -- -std=c++11
+// RUN: %check_clang_tidy %s performance-for-range-copy %t -- \
+// RUN:     -config="{CheckOptions: [{key: "performance-for-range-copy.WarnOnAllAutoCopies", value: 1}]}"
 
 template <typename T>
 struct Iterator {
   void operator++() {}
   const T& operator*() {
     static T* TT = new T();
     return *TT;
   }

clang-tools-extra/test/clang-tidy/performance-for-range-copy.cpp

-// RUN: %check_clang_tidy %s performance-for-range-copy %t -- -- -std=c++11 -fno-delayed-template-parsing
+// RUN: %check_clang_tidy %s performance-for-range-copy %t -- -- -fno-delayed-template-parsing
 
 namespace std {
 
 template <typename _Tp>
 struct remove_reference { typedef _Tp type; };
 template <typename _Tp>
 struct remove_reference<_Tp&> { typedef _Tp type; };
 template <typename _Tp>

clang-tools-extra/test/clang-tidy/performance-inefficient-algorithm.cpp

-// RUN: %check_clang_tidy %s performance-inefficient-algorithm %t
+// RUN: %check_clang_tidy -std=c++11,c++14 %s performance-inefficient-algorithm %t
+// FIXME: Fix the checker to work in C++17 mode.
 
 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; }

clang-tools-extra/test/clang-tidy/performance-inefficient-vector-operation.cpp

-// RUN: %check_clang_tidy %s performance-inefficient-vector-operation %t -- -format-style=llvm -- --std=c++11
+// RUN: %check_clang_tidy %s performance-inefficient-vector-operation %t -- -format-style=llvm
 
 namespace std {
 
 typedef int size_t;
 
 template<class E> class initializer_list {
 public:
   using value_type = E;

clang-tools-extra/test/clang-tidy/performance-move-const-arg-trivially-copyable.cpp

 // RUN: %check_clang_tidy %s performance-move-const-arg %t \
 // RUN: -config='{CheckOptions: \
-// RUN:  [{key: performance-move-const-arg.CheckTriviallyCopyableMove, value: 0}]}' \
-// RUN: -- -std=c++14
+// RUN:  [{key: performance-move-const-arg.CheckTriviallyCopyableMove, value: 0}]}'
 
 namespace std {
 
 template <typename> struct remove_reference;
 template <typename _Tp> struct remove_reference { typedef _Tp type; };
 template <typename _Tp> struct remove_reference<_Tp &> { typedef _Tp type; };
 template <typename _Tp> struct remove_reference<_Tp &&> { typedef _Tp type; };
 

clang-tools-extra/test/clang-tidy/performance-move-constructor-init.cpp

 // RUN: %check_clang_tidy %s performance-move-constructor-init,modernize-pass-by-value %t -- \
 // RUN: -config='{CheckOptions: \
 // RUN:  [{key: modernize-pass-by-value.ValuesOnly, value: 1}]}' \
-// RUN: -- -std=c++11 -isystem %S/Inputs/Headers
+// RUN: -- -isystem %S/Inputs/Headers
 
 #include <s.h>
 
 // CHECK-FIXES: #include <utility>
 
 template <class T> struct remove_reference      {typedef T type;};
 template <class T> struct remove_reference<T&>  {typedef T type;};
 template <class T> struct remove_reference<T&&> {typedef T type;};

clang-tools-extra/test/clang-tidy/performance-unnecessary-value-param-header.cpp

 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: cp %S/Inputs/performance-unnecessary-value-param/header.h %t/header.h
-// RUN: %check_clang_tidy %s performance-unnecessary-value-param %t/temp -- -- -std=c++11 -I %t
+// RUN: %check_clang_tidy -std=c++11 %s performance-unnecessary-value-param %t/temp -- -- -I %t
 // RUN: diff %t/header.h %S/Inputs/performance-unnecessary-value-param/header-fixed.h
+// FIXME: Make the test work in all language modes.
 
 #include "header.h"
 
 
 
 int f1(int n, ABC v1, ABC v2) {
   // CHECK-MESSAGES: [[@LINE-1]]:19: warning: the parameter 'v1' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param]
   // CHECK-MESSAGES: [[@LINE-2]]:27: warning: the parameter 'v2' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param]
   // CHECK-FIXES: int f1(int n, const ABC& v1, const ABC& v2) {
   return v1.get(n) + v2.get(n);
 }
 int f2(int n, ABC v2) {
   // CHECK-MESSAGES: [[@LINE-1]]:19: warning: the parameter 'v2' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param]
   // CHECK-FIXES: int f2(int n, const ABC& v2) {
 }

clang-tools-extra/test/clang-tidy/performance-unnecessary-value-param-incomplete-type.cpp

-// RUN: %check_clang_tidy %s performance-unnecessary-value-param %t -- -fix-errors -- --std=c++11
+// RUN: %check_clang_tidy %s performance-unnecessary-value-param %t -- -fix-errors
 
 // Ensure that incomplete types result in an error from the frontend and not a
 // clang-tidy diagnostic about IncompleteType being expensive to copy.
 struct IncompleteType;
 void NegativeForIncompleteType(IncompleteType I) {
   // CHECK-MESSAGES: [[@LINE-1]]:47: error: variable has incomplete type 'IncompleteType' [clang-diagnostic-error]
 }
 

clang-tools-extra/test/clang-tidy/portability-simd-intrinsics-ppc.cpp

-// RUN: %check_clang_tidy %s portability-simd-intrinsics %t -- \
+// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s portability-simd-intrinsics %t -- \
 // RUN:  -config='{CheckOptions: [ \
 // RUN:    {key: portability-simd-intrinsics.Suggest, value: 1} \
-// RUN:  ]}' -- -target ppc64le -maltivec -std=c++11
+// RUN:  ]}' -- -target ppc64le -maltivec
+// FIXME: Fix the checker to work in C++2a mode.
 
 vector int vec_add(vector int, vector int);
 
 void PPC() {
   vector int i0, i1;
 
   vec_add(i0, i1);
 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'vec_add' can be replaced by operator+ on std::experimental::simd objects [portability-simd-intrinsics]
 }

clang-tools-extra/test/clang-tidy/portability-simd-intrinsics-x86.cpp

-// RUN: %check_clang_tidy %s portability-simd-intrinsics %t -- \
+// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s portability-simd-intrinsics %t -- \
 // RUN:  -config='{CheckOptions: [ \
 // RUN:    {key: portability-simd-intrinsics.Suggest, value: 1} \
-// RUN:  ]}' -- -target x86_64 -std=c++11
+// RUN:  ]}' -- -target x86_64
+// FIXME: Fix the checker to work in C++2a mode.
 
 typedef long long __m128i __attribute__((vector_size(16)));
 typedef double __m256 __attribute__((vector_size(32)));
 
 __m128i _mm_add_epi32(__m128i, __m128i);
 __m256 _mm256_load_pd(double const *);
 void _mm256_store_pd(double *, __m256);
 

clang-tools-extra/test/clang-tidy/readability-deleted-default.cpp

-// RUN: %check_clang_tidy %s readability-deleted-default %t -- -- -std=c++11 -fno-ms-compatibility
+// RUN: %check_clang_tidy %s readability-deleted-default %t -- -- -fno-ms-compatibility
 
 class NoDefault {
 public:
   NoDefault() = delete;
   NoDefault(NoDefault &&Other) = delete;
   NoDefault(const NoDefault &Other) = delete;
 };
 

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

-// RUN: %check_clang_tidy %s readability-else-after-return %t -- -- -std=c++11 -fexceptions
+// RUN: %check_clang_tidy %s readability-else-after-return %t -- -- -fexceptions
 
 namespace std {
 struct string {
   string(const char *);
   ~string();
 };
 } // namespace std
 

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

-// RUN: %check_clang_tidy %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}, {key: readability-function-size.ParameterThreshold, value: 5}, {key: readability-function-size.NestingThreshold, value: 2}, {key: readability-function-size.VariableThreshold, value: 1}]}' -- -std=c++11
+// RUN: %check_clang_tidy %s readability-function-size %t -- \
+// RUN:     -config='{CheckOptions: [ \
+// RUN:         {key: readability-function-size.LineThreshold, value: 0}, \
+// RUN:         {key: readability-function-size.StatementThreshold, value: 0}, \
+// RUN:         {key: readability-function-size.BranchThreshold, value: 0}, \
+// RUN:         {key: readability-function-size.ParameterThreshold, value: 5}, \
+// RUN:         {key: readability-function-size.NestingThreshold, value: 2}, \
+// RUN:         {key: readability-function-size.VariableThreshold, value: 1} \
+// RUN:     ]}'
 
 // Bad formatting is intentional, don't run clang-format over the whole file!
 
 void foo1() {
 }
 
 void foo2() {;}
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'foo2' exceeds recommended size/complexity thresholds [readability-function-size]

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

 // RUN:     {key: readability-identifier-naming.PointerParameterCase, value: lower_case}, \
 // RUN:     {key: readability-identifier-naming.PointerParameterPrefix, value: 'p_'}, \
 // RUN:     {key: readability-identifier-naming.ConstantPointerParameterCase, value: CamelCase}, \
 // RUN:     {key: readability-identifier-naming.ConstantPointerParameterPrefix, value: 'cp_'}, \
 // RUN:     {key: readability-identifier-naming.LocalPointerCase, value: CamelCase}, \
 // RUN:     {key: readability-identifier-naming.LocalPointerPrefix, value: 'l_'}, \
 // RUN:     {key: readability-identifier-naming.LocalConstantPointerCase, value: CamelCase}, \
 // RUN:     {key: readability-identifier-naming.LocalConstantPointerPrefix, value: 'lc_'}, \
-// RUN:   ]}' -- -std=c++11 -fno-delayed-template-parsing \
+// RUN:   ]}' -- -fno-delayed-template-parsing \
 // RUN:   -I%S/Inputs/readability-identifier-naming \
 // RUN:   -isystem %S/Inputs/readability-identifier-naming/system
 
 // clang-format off
 
 #include <system-header.h>
 #include "user-header.h"
 // NO warnings or fixes expected from declarations within header files without

clang-tools-extra/test/clang-tidy/readability-implicit-bool-conversion-allow-in-conditions.cpp

 // RUN: %check_clang_tidy %s readability-implicit-bool-conversion %t \
 // RUN: -config='{CheckOptions: \
 // RUN:  [{key: readability-implicit-bool-conversion.AllowIntegerConditions, value: 1}, \
-// RUN:   {key: readability-implicit-bool-conversion.AllowPointerConditions, value: 1}]}' \
-// RUN: -- -std=c++11
+// RUN:   {key: readability-implicit-bool-conversion.AllowPointerConditions, value: 1}]}'
 
 template<typename T>
 void functionTaking(T);
 
 int functionReturningInt();
 int* functionReturningPointer();
 
 struct Struct {

clang-tools-extra/test/clang-tidy/readability-implicit-bool-conversion-cxx98.cpp

-// RUN: %check_clang_tidy %s readability-implicit-bool-conversion %t -- -- -std=c++98
+// RUN: %check_clang_tidy -std=c++98 %s readability-implicit-bool-conversion %t
 
 // We need NULL macro, but some buildbots don't like including <cstddef> header
 // This is a portable way of getting it to work
 #undef NULL
 #define NULL 0L
 
 template<typename T>
 void functionTaking(T);

clang-tools-extra/test/clang-tidy/readability-inconsistent-declaration-parameter-name-macros.cpp

 // RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- \
-// RUN:   -config="{CheckOptions: [{key: readability-inconsistent-declaration-parameter-name.IgnoreMacros, value: 0}]}" \
-// RUN:   -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: readability-inconsistent-declaration-parameter-name.IgnoreMacros, value: 0}]}"
 
 #define MACRO() \
   void f(int x)
 
 struct S1 {
   MACRO();
   // CHECK-NOTES: :[[@LINE-1]]:3: warning: function 'S1::f' has a definition with different parameter names
   // CHECK-NOTES: :[[@LINE-5]]:8: note: expanded from macro 'MACRO'

clang-tools-extra/test/clang-tidy/readability-inconsistent-declaration-parameter-name-strict.cpp

 // RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- \
-// RUN:   -config="{CheckOptions: [{key: readability-inconsistent-declaration-parameter-name.Strict, value: 1}]}" \
-// RUN:   -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: readability-inconsistent-declaration-parameter-name.Strict, value: 1}]}"
 
 void inconsistentFunction(int a, int b, int c);
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'inconsistentFunction' has 1 other declaration with different parameter names
 void inconsistentFunction(int prefixA, int b, int cSuffix);
 // CHECK-MESSAGES: :[[@LINE-1]]:6: note: the 1st inconsistent declaration seen here
 // CHECK-MESSAGES: :[[@LINE-2]]:6: note: differing parameters are named here: ('prefixA', 'cSuffix'), in the other declaration: ('a', 'c')
 void inconsistentFunction(int a, int b, int c);
 void inconsistentFunction(int /*c*/, int /*c*/, int /*c*/);

clang-tools-extra/test/clang-tidy/readability-inconsistent-declaration-parameter-name.cpp

-// RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- -- -std=c++11 -fno-delayed-template-parsing
+// RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- -- -fno-delayed-template-parsing
 
 void consistentFunction(int a, int b, int c);
 void consistentFunction(int a, int b, int c);
 void consistentFunction(int prefixA, int b, int cSuffix);
 void consistentFunction(int a, int b, int c);
 void consistentFunction(int a, int b, int /*c*/);
 void consistentFunction(int /*c*/, int /*c*/, int /*c*/);
 

clang-tools-extra/test/clang-tidy/readability-isolate-declaration-cxx17.cpp

-// RUN: %check_clang_tidy %s readability-isolate-declaration %t -- -- -std=c++17
+// RUN: %check_clang_tidy -std=c++17 %s readability-isolate-declaration %t
 
 template <typename T1, typename T2>
 struct pair {
   T1 first;
   T2 second;
   pair(T1 v1, T2 v2) : first(v1), second(v2) {}
 
   template <int N>

clang-tools-extra/test/clang-tidy/readability-redundant-declaration-ignore-macros.cpp

 // RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: readability-redundant-declaration.IgnoreMacros, \
-// RUN:               value: 1}]}" \
-// RUN:   -- -std=c++11
+// RUN:               value: 1}]}"
 
 extern int Xyz;
 extern int Xyz; // Xyz
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Xyz' declaration [readability-redundant-declaration]
 // CHECK-FIXES: {{^}}// Xyz{{$}}
 
 namespace macros {
 #define DECLARE(x) extern int x

clang-tools-extra/test/clang-tidy/readability-redundant-declaration.cpp

 // RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \
 // RUN:   -config="{CheckOptions: \
 // RUN:             [{key: readability-redundant-declaration.IgnoreMacros, \
-// RUN:               value: 0}]}" \
-// RUN:   -- -std=c++11
+// RUN:               value: 0}]}"
 
 extern int Xyz;
 extern int Xyz; // Xyz
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Xyz' declaration [readability-redundant-declaration]
 // CHECK-FIXES: {{^}}// Xyz{{$}}
 int Xyz = 123;
 
 extern int A;

clang-tools-extra/test/clang-tidy/readability-redundant-smartptr-get-macros.cpp

 // RUN: %check_clang_tidy %s readability-redundant-smartptr-get %t -- \
-// RUN:   -config="{CheckOptions: [{key: readability-redundant-smartptr-get.IgnoreMacros, value: 0}]}" \
-// RUN:   -- -std=c++11
+// RUN:   -config="{CheckOptions: [{key: readability-redundant-smartptr-get.IgnoreMacros, value: 0}]}"
 
 namespace std {
 
 template <typename T>
 struct shared_ptr {
   T &operator*() const;
   T *operator->() const;
   T *get() const;

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

-// RUN: %check_clang_tidy %s readability-redundant-string-cstr %t -- -- -std=c++11
+// RUN: %check_clang_tidy %s readability-redundant-string-cstr %t
 
 typedef unsigned __INT16_TYPE__ char16;
 typedef unsigned __INT32_TYPE__ char32;
 typedef __SIZE_TYPE__ size;
 
 namespace std {
 template <typename T>
 class allocator {};

clang-tools-extra/test/clang-tidy/readability-redundant-string-init-msvc.cpp

-// RUN: %check_clang_tidy %s readability-redundant-string-init %t
+// RUN: %check_clang_tidy -std=c++11,c++14 %s readability-redundant-string-init %t
+// FIXME: Fix the checker to work in C++17 mode.
 
 namespace std {
 template <typename T>
 class allocator {};
 template <typename T>
 class char_traits {};
 template <typename C, typename T = std::char_traits<C>, typename A = std::allocator<C>>
 struct basic_string {

clang-tools-extra/test/clang-tidy/readability-redundant-string-init.cpp

-// RUN: %check_clang_tidy %s readability-redundant-string-init %t
+// RUN: %check_clang_tidy -std=c++11,c++14 %s readability-redundant-string-init %t
+// FIXME: Fix the checker to work in C++17 mode.
 
 namespace std {
 template <typename T>
 class allocator {};
 template <typename T>
 class char_traits {};
 template <typename C, typename T = std::char_traits<C>, typename A = std::allocator<C>>
 struct basic_string {

clang-tools-extra/test/clang-tidy/readability-string-compare.cpp

-// RUN: %check_clang_tidy %s readability-string-compare %t -- -- -std=c++11
+// RUN: %check_clang_tidy %s readability-string-compare %t
 
 namespace std {
 template <typename T>
 class allocator {};
 template <typename T>
 class char_traits {};
 template <typename C, typename T = std::char_traits<C>, typename A = std::allocator<C>>
 class basic_string {

clang-tools-extra/test/clang-tidy/readability-uppercase-literal-suffix-floating-point-opencl-half.cpp

-// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %S -std=cl2.0 -x cl
+// RUN: %check_clang_tidy -std=cl2.0 %s readability-uppercase-literal-suffix %t -- -- -target x86_64-pc-linux-gnu -I %S -x cl
 // RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
 // RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -- -target x86_64-pc-linux-gnu -I %S -std=cl2.0 -x cl
 // RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -- -target x86_64-pc-linux-gnu -I %S -std=cl2.0 -x cl
 
 #pragma OPENCL EXTENSION cl_khr_fp16 : enable
 
 void floating_point_half_suffix() {
   static half v0 = 0x0p0; // no literal

clang-tools-extra/test/clang-tidy/zircon-temporary-objects.cpp

 // RUN: %check_clang_tidy %s zircon-temporary-objects %t -- \
 // RUN:   -config="{CheckOptions: [{key: zircon-temporary-objects.Names, value: 'Foo;NS::Bar'}]}" \
-// RUN:   -header-filter=.* \
-// RUN: -- -std=c++11
+// RUN:   -header-filter=.*
 
 // Should flag instances of Foo, NS::Bar.
 
 class Foo {
 public:
   Foo() = default;
   Foo(int Val) : Val(Val){};