This is an archive of the discontinued LLVM Phabricator instance.

Differential D130209

[clang-tidy][NFC] Update tests to specify CheckOptions using new syntax
ClosedPublic

Authored by njames93 on Jul 20 2022, 3:42 PM.

Details

Reviewers
aaron.ballman
jdoerfert
PiotrZSL
lebedev.ri
Commits
rGe8a3ddafe063: [clang-tidy][NFC] Update tests to specify CheckOptions using new syntax
Summary

In D128337, The spelling of CheckOptions was updated to support a more natural dictionary syntax.
This patch is just updating all test files to use the new syntax.

Diff Detail

Event Timeline

njames93 created this revision.Jul 20 2022, 3:42 PM
Herald added a reviewer: lebedev.ri. · View Herald TranscriptJul 20 2022, 3:42 PM
Herald added a reviewer: lebedev.ri. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: lebedev.ri, arphaman, zzheng and 3 others. · View Herald Transcript
njames93 requested review of this revision.Jul 20 2022, 3:42 PM
Herald added a reviewer: jdoerfert. · View Herald TranscriptJul 20 2022, 3:42 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: cfe-commits, sstefan1, aheejin. · View Herald Transcript
Harbormaster completed remote builds in B176612: Diff 446288.Jul 20 2022, 3:58 PM
lebedev.ri resigned from this revision.Jan 12 2023, 5:31 PM

This review may be stuck/dead, consider abandoning if no longer relevant.
Removing myself as reviewer in attempt to clean dashboard.

Herald added a subscriber: StephenFan. · View Herald TranscriptJan 12 2023, 5:31 PM
PiotrZSL accepted this revision.Aug 7 2023, 9:02 AM
PiotrZSL added a subscriber: PiotrZSL.

LGTM, minor conflicts only...

This revision is now accepted and ready to land.Aug 7 2023, 9:02 AM
Herald added subscribers: jplehr, carlosgalvezp. · View Herald TranscriptAug 7 2023, 9:02 AM
PiotrZSL updated this revision to Diff 547814.Aug 7 2023, 9:02 AM

Rebase + conflict resolution

Harbormaster completed remote builds in B250809: Diff 547814.Aug 7 2023, 11:31 AM
Closed by commit rGe8a3ddafe063: [clang-tidy][NFC] Update tests to specify CheckOptions using new syntax (authored by njames93, committed by PiotrZSL). · Explain WhyAug 7 2023, 12:33 PM
This revision was automatically updated to reflect the committed changes.
PiotrZSL added a commit: rGe8a3ddafe063: [clang-tidy][NFC] Update tests to specify CheckOptions using new syntax.
PiotrZSL mentioned this in rG1af159e98c23: [clang-tidy][NFC] Update tests to CheckOptions using new syntax.

Revision Contents

PathSize
clang-tools-extra/
test/
clang-tidy/
checkers/
abseil/
2 lines
3 lines
altera/
4 lines
4 lines
android/
2 lines
bugprone/
18 lines
16 lines
2 lines
2 lines
4 lines
18 lines
18 lines
18 lines
18 lines
18 lines
18 lines
18 lines
18 lines
18 lines
18 lines
18 lines
8 lines
12 lines
12 lines
12 lines
2 lines
2 lines
3 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
3 lines
3 lines
4 lines
cert/
2 lines
2 lines
6 lines
concurrency/
2 lines
2 lines
cppcoreguidelines/
2 lines
4 lines
2 lines
9 lines
10 lines
10 lines
4 lines
4 lines
5 lines
5 lines
6 lines
6 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
google/
10 lines
hicpp/
2 lines
2 lines
misc/
8 lines
2 lines
modernize/
4 lines
2 lines
2 lines
2 lines
22 lines
2 lines
8 lines
4 lines
8 lines
2 lines
2 lines
2 lines
24 lines
2 lines
2 lines
8 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
5 lines
13 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
objc/
2 lines
openmp/
2 lines
performance/
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
portability/
2 lines
2 lines
2 lines
2 lines
12 lines
12 lines
readability/
Inputs/
identifier-naming/
global-style1/
6 lines
global-style2/
6 lines
hungarian-notation1/
168 lines
hungarian-notation2/
405 lines
2 lines
2 lines
2 lines
6 lines
6 lines
30 lines
2 lines
2 lines
16 lines
2 lines
6 lines
14 lines
16 lines
8 lines
12 lines
20 lines
2 lines
160 lines
4 lines
2 lines
2 lines
2 lines
8 lines
2 lines
4 lines
12 lines
4 lines
2 lines
4 lines
2 lines
2 lines
10 lines
4 lines
2 lines
2 lines
6 lines
2 lines
zircon/
2 lines
infrastructure/
6 lines
16 lines
3 lines
2 lines
8 lines

Diff 446288

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

// RUN: %check_clang_tidy %s abseil-string-find-startswith %t -- \ // 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: -config="{CheckOptions: {abseil-string-find-startswith.StringLikeClasses: '::std::basic_string;::basic_string'}}"
using size_t = decltype(sizeof(int)); using size_t = decltype(sizeof(int));
namespace std { namespace std {
template <typename T> class allocator {}; template <typename T> class allocator {};
template <typename T> class char_traits {}; template <typename T> class char_traits {};
template <typename C, typename T = std::char_traits<C>, template <typename C, typename T = std::char_traits<C>,
typename A = std::allocator<C>> typename A = std::allocator<C>>
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/abseil/string-find-str-contains.cpp

// RUN: %check_clang_tidy %s abseil-string-find-str-contains %t -- \ // RUN: %check_clang_tidy %s abseil-string-find-str-contains %t --
// RUN: -config="{CheckOptions: []}"
using size_t = decltype(sizeof(int)); using size_t = decltype(sizeof(int));
namespace std { namespace std {
// Lightweight standin for std::string. // Lightweight standin for std::string.
template <typename C> template <typename C>
class basic_string { class basic_string {
▲ Show 20 Lines • Show All 295 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/altera/single-work-item-barrier.cpp

// RUN: %check_clang_tidy -check-suffix=OLDCLOLDAOC %s altera-single-work-item-barrier %t -- -header-filter=.* "--" -cl-std=CL1.2 -c -DOLDCLOLDAOC // RUN: %check_clang_tidy -check-suffix=OLDCLOLDAOC %s altera-single-work-item-barrier %t -- -header-filter=.* "--" -cl-std=CL1.2 -c -DOLDCLOLDAOC
// RUN: %check_clang_tidy -check-suffix=NEWCLOLDAOC %s altera-single-work-item-barrier %t -- -header-filter=.* "--" -cl-std=CL2.0 -c -DNEWCLOLDAOC // RUN: %check_clang_tidy -check-suffix=NEWCLOLDAOC %s altera-single-work-item-barrier %t -- -header-filter=.* "--" -cl-std=CL2.0 -c -DNEWCLOLDAOC
// RUN: %check_clang_tidy -check-suffix=OLDCLNEWAOC %s altera-single-work-item-barrier %t -- -config='{CheckOptions: [{key: altera-single-work-item-barrier.AOCVersion, value: 1701}]}' -header-filter=.* "--" -cl-std=CL1.2 -c -DOLDCLNEWAOC // RUN: %check_clang_tidy -check-suffix=OLDCLNEWAOC %s altera-single-work-item-barrier %t -- -config='{CheckOptions: { altera-single-work-item-barrier.AOCVersion: 1701}}' -header-filter=.* "--" -cl-std=CL1.2 -c -DOLDCLNEWAOC
// RUN: %check_clang_tidy -check-suffix=NEWCLNEWAOC %s altera-single-work-item-barrier %t -- -config='{CheckOptions: [{key: altera-single-work-item-barrier.AOCVersion, value: 1701}]}' -header-filter=.* "--" -cl-std=CL2.0 -c -DNEWCLNEWAOC // RUN: %check_clang_tidy -check-suffix=NEWCLNEWAOC %s altera-single-work-item-barrier %t -- -config='{CheckOptions: { altera-single-work-item-barrier.AOCVersion: 1701}}' -header-filter=.* "--" -cl-std=CL2.0 -c -DNEWCLNEWAOC
#ifdef OLDCLOLDAOC // OpenCL 1.2 Altera Offline Compiler < 17.1 #ifdef OLDCLOLDAOC // OpenCL 1.2 Altera Offline Compiler < 17.1
void __kernel error_barrier_no_id(__global int * foo, int size) { void __kernel error_barrier_no_id(__global int * foo, int size) {
// CHECK-MESSAGES-OLDCLOLDAOC: :[[@LINE-1]]:15: warning: kernel function 'error_barrier_no_id' does not call 'get_global_id' or 'get_local_id' and will be treated as a single work-item [altera-single-work-item-barrier] // CHECK-MESSAGES-OLDCLOLDAOC: :[[@LINE-1]]:15: warning: kernel function 'error_barrier_no_id' does not call 'get_global_id' or 'get_local_id' and will be treated as a single work-item [altera-single-work-item-barrier]
for (int j = 0; j < 256; j++) { for (int j = 0; j < 256; j++) {
for (int i = 256; i < size; i+= 256) { for (int i = 256; i < size; i+= 256) {
foo[j] += foo[j+i]; foo[j] += foo[j+i];
} }
▲ Show 20 Lines • Show All 288 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/altera/unroll-loops.cpp

// RUN: %check_clang_tidy %s altera-unroll-loops %t -- -config="{CheckOptions: [{key: "altera-unroll-loops.MaxLoopIterations", value: 50}]}" -header-filter=.* // RUN: %check_clang_tidy %s altera-unroll-loops %t -- -config="{CheckOptions: {altera-unroll-loops.MaxLoopIterations: 50}}" -header-filter=.*
// RUN: %check_clang_tidy -check-suffix=MULT %s altera-unroll-loops %t -- -config="{CheckOptions: [{key: "altera-unroll-loops.MaxLoopIterations", value: 5}]}" -header-filter=.* "--" -DMULT // RUN: %check_clang_tidy -check-suffix=MULT %s altera-unroll-loops %t -- -config="{CheckOptions: {altera-unroll-loops.MaxLoopIterations: 5}}" -header-filter=.* "--" -DMULT
#ifdef MULT #ifdef MULT
// For loops with *= and /= increments. // For loops with *= and /= increments.
void for_loop_mult_div_increments(int *A) { void for_loop_mult_div_increments(int *A) {
// *= // *=
#pragma unroll #pragma unroll
for (int i = 2; i <= 32; i *= 2) for (int i = 2; i <= 32; i *= 2)
A[i]++; // OK A[i]++; // OK
▲ Show 20 Lines • Show All 506 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/android/comparison-in-temp-failure-retry-custom-macro.c

// RUN: %check_clang_tidy %s android-comparison-in-temp-failure-retry %t -- -config="{CheckOptions: [{key: android-comparison-in-temp-failure-retry.RetryMacros, value: 'MY_TEMP_FAILURE_RETRY,MY_OTHER_TEMP_FAILURE_RETRY'}]}" // RUN: %check_clang_tidy %s android-comparison-in-temp-failure-retry %t -- -config="{CheckOptions: {android-comparison-in-temp-failure-retry.RetryMacros: 'MY_TEMP_FAILURE_RETRY,MY_OTHER_TEMP_FAILURE_RETRY'}}"
#define MY_TEMP_FAILURE_RETRY(x) \ #define MY_TEMP_FAILURE_RETRY(x) \
({ \ ({ \
typeof(x) __z; \ typeof(x) __z; \
do \ do \
__z = (x); \ __z = (x); \
while (__z == -1); \ while (__z == -1); \
__z; \ __z; \
Show All 37 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/argument-comment-ignore-single-argument.cpp

// RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \ // RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: bugprone-argument-comment.IgnoreSingleArgument, value: true}, \ // RUN: bugprone-argument-comment.IgnoreSingleArgument: true, \
// RUN: {key: bugprone-argument-comment.CommentBoolLiterals, value: true}, \ // RUN: bugprone-argument-comment.CommentBoolLiterals: true, \
// RUN: {key: bugprone-argument-comment.CommentIntegerLiterals, value: true}, \ // RUN: bugprone-argument-comment.CommentIntegerLiterals: true, \
// RUN: {key: bugprone-argument-comment.CommentFloatLiterals, value: true}, \ // RUN: bugprone-argument-comment.CommentFloatLiterals: true, \
// RUN: {key: bugprone-argument-comment.CommentUserDefinedLiterals, value: true}, \ // RUN: bugprone-argument-comment.CommentUserDefinedLiterals: true, \
// RUN: {key: bugprone-argument-comment.CommentStringLiterals, value: true}, \ // RUN: bugprone-argument-comment.CommentStringLiterals: true, \
// RUN: {key: bugprone-argument-comment.CommentNullPtrs, value: true}, \ // RUN: bugprone-argument-comment.CommentNullPtrs: true, \
// RUN: {key: bugprone-argument-comment.CommentCharacterLiterals, value: true}]}" -- // RUN: bugprone-argument-comment.CommentCharacterLiterals: true}}" --
struct A { struct A {
void foo(bool abc); void foo(bool abc);
void foo(bool abc, bool cde); void foo(bool abc, bool cde);
void foo(const char *, bool abc); void foo(const char *, bool abc);
void foo(int iabc); void foo(int iabc);
void foo(float fabc); void foo(float fabc);
void foo(double dabc); void foo(double dabc);
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/argument-comment-literals.cpp

// RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \ // RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: bugprone-argument-comment.CommentBoolLiterals, value: true}, \ // RUN: bugprone-argument-comment.CommentBoolLiterals: true, \
// RUN: {key: bugprone-argument-comment.CommentIntegerLiterals, value: true}, \ // RUN: bugprone-argument-comment.CommentIntegerLiterals: true, \
// RUN: {key: bugprone-argument-comment.CommentFloatLiterals, value: true}, \ // RUN: bugprone-argument-comment.CommentFloatLiterals: true, \
// RUN: {key: bugprone-argument-comment.CommentUserDefinedLiterals, value: true}, \ // RUN: bugprone-argument-comment.CommentUserDefinedLiterals: true, \
// RUN: {key: bugprone-argument-comment.CommentStringLiterals, value: true}, \ // RUN: bugprone-argument-comment.CommentStringLiterals: true, \
// RUN: {key: bugprone-argument-comment.CommentNullPtrs, value: true}, \ // RUN: bugprone-argument-comment.CommentNullPtrs: true, \
// RUN: {key: bugprone-argument-comment.CommentCharacterLiterals, value: true}]}" -- // RUN: bugprone-argument-comment.CommentCharacterLiterals: true}}" --
struct A { struct A {
void foo(bool abc); void foo(bool abc);
void foo(bool abc, bool cde); void foo(bool abc, bool cde);
void foo(const char *, bool abc); void foo(const char *, bool abc);
void foo(int iabc); void foo(int iabc);
void foo(float fabc); void foo(float fabc);
void foo(double dabc); void foo(double dabc);
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/argument-comment-strict.cpp

// RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \ // RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \
// RUN: -config="{CheckOptions: [{key: StrictMode, value: true}]}" -- // RUN: -config="{CheckOptions: {StrictMode: true}}" --
void f(int _with_underscores_); void f(int _with_underscores_);
void g(int x_); void g(int x_);
void ignores_underscores() { void ignores_underscores() {
f(/*With_Underscores=*/0); f(/*With_Underscores=*/0);
// CHECK-NOTES: [[@LINE-1]]:5: warning: argument name 'With_Underscores' in comment does not match parameter name '_with_underscores_' // CHECK-NOTES: [[@LINE-1]]:5: warning: argument name 'With_Underscores' in comment does not match parameter name '_with_underscores_'
// CHECK-NOTES: [[@LINE-5]]:12: note: '_with_underscores_' declared here // CHECK-NOTES: [[@LINE-5]]:12: note: '_with_underscores_' declared here
// CHECK-FIXES: f(/*_with_underscores_=*/0); // CHECK-FIXES: f(/*_with_underscores_=*/0);
Show All 14 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/assert-side-effect.cpp

// RUN: %check_clang_tidy %s bugprone-assert-side-effect %t -- -config="{CheckOptions: [{key: bugprone-assert-side-effect.CheckFunctionCalls, value: true}, {key: bugprone-assert-side-effect.AssertMacros, value: 'assert,assert2,my_assert,convoluted_assert,msvc_assert'}, {key: bugprone-assert-side-effect.IgnoredFunctions, value: 'MyClass::badButIgnoredFunc'}]}" -- -fexceptions // RUN: %check_clang_tidy %s bugprone-assert-side-effect %t -- -config="{CheckOptions: {bugprone-assert-side-effect.CheckFunctionCalls: true, bugprone-assert-side-effect.AssertMacros: 'assert,assert2,my_assert,convoluted_assert,msvc_assert', bugprone-assert-side-effect.IgnoredFunctions: 'MyClass::badButIgnoredFunc'}}" -- -fexceptions
//===--- assert definition block ------------------------------------------===// //===--- assert definition block ------------------------------------------===//
int abort() { return 0; } int abort() { return 0; }
#ifdef NDEBUG #ifdef NDEBUG
#define assert(x) 1 #define assert(x) 1
#else #else
#define assert(x) \ #define assert(x) \
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

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

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

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-ignore.cpp

// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 2, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: "\"\";Foo;Bar"}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "\"\";Foo;Bar", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: "T"}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "T", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 0 \
// RUN: ]}' -- // RUN: }}' --
void ignoredUnnamed(int I, int, int) {} // NO-WARN: No >= 2 length of non-unnamed. void ignoredUnnamed(int I, int, int) {} // NO-WARN: No >= 2 length of non-unnamed.
void nothingIgnored(int I, int J) {} void nothingIgnored(int I, int J) {}
// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: 2 adjacent parameters of 'nothingIgnored' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: 2 adjacent parameters of 'nothingIgnored' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
// CHECK-MESSAGES: :[[@LINE-2]]:25: note: the first parameter in the range is 'I' // CHECK-MESSAGES: :[[@LINE-2]]:25: note: the first parameter in the range is 'I'
// CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in the range is 'J' // CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in the range is 'J'
Show All 19 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-implicit-qualifiers.cpp

// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 2, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 1}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 1, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 1}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 1, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 0 \
// RUN: ]}' -- // RUN: }}' --
void numericAndQualifierConversion(int I, const double CD) { numericAndQualifierConversion(CD, I); } void numericAndQualifierConversion(int I, const double CD) { numericAndQualifierConversion(CD, I); }
// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'numericAndQualifierConversion' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters] // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'numericAndQualifierConversion' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters]
// CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'I' // CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'I'
// CHECK-MESSAGES: :[[@LINE-3]]:56: note: the last parameter in the range is 'CD' // CHECK-MESSAGES: :[[@LINE-3]]:56: note: the last parameter in the range is 'CD'
// CHECK-MESSAGES: :[[@LINE-4]]:43: note: 'int' and 'const double' parameters accept and bind the same kind of values // CHECK-MESSAGES: :[[@LINE-4]]:43: note: 'int' and 'const double' parameters accept and bind the same kind of values
// CHECK-MESSAGES: :[[@LINE-5]]:43: note: 'int' and 'const double' may be implicitly converted: 'int' -> 'const double' (as 'double'), 'const double' (as 'double') -> 'int' // CHECK-MESSAGES: :[[@LINE-5]]:43: note: 'int' and 'const double' may be implicitly converted: 'int' -> 'const double' (as 'double'), 'const double' (as 'double') -> 'int'

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-implicits.c

// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 2, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 1}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 1, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 0 \
// RUN: ]}' -- // RUN: }}' --
void implicitDoesntBreakOtherStuff(int A, int B) {} void implicitDoesntBreakOtherStuff(int A, int B) {}
// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'implicitDoesntBreakOtherStuff' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'implicitDoesntBreakOtherStuff' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
// CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'A' // CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'A'
// CHECK-MESSAGES: :[[@LINE-3]]:47: note: the last parameter in the range is 'B' // CHECK-MESSAGES: :[[@LINE-3]]:47: note: the last parameter in the range is 'B'
void arrayAndPtr1(int *IP, int IA[]) { arrayAndPtr1(IA, IP); } void arrayAndPtr1(int *IP, int IA[]) { arrayAndPtr1(IA, IP); }
// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters of 'arrayAndPtr1' of similar type ('int *') // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters of 'arrayAndPtr1' of similar type ('int *')
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-implicits.cpp

// RUN: %check_clang_tidy -std=c++17 %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy -std=c++17 %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 2, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 1}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 1, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 0 \
// RUN: ]}' -- // RUN: }}' --
void implicitDoesntBreakOtherStuff(int A, int B) {} void implicitDoesntBreakOtherStuff(int A, int B) {}
// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'implicitDoesntBreakOtherStuff' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'implicitDoesntBreakOtherStuff' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
// CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'A' // CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'A'
// CHECK-MESSAGES: :[[@LINE-3]]:47: note: the last parameter in the range is 'B' // CHECK-MESSAGES: :[[@LINE-3]]:47: note: the last parameter in the range is 'B'
void arrayAndPtr1(int *IP, int IA[]) { arrayAndPtr1(IA, IP); } void arrayAndPtr1(int *IP, int IA[]) { arrayAndPtr1(IA, IP); }
// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters of 'arrayAndPtr1' of similar type ('int *') // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters of 'arrayAndPtr1' of similar type ('int *')
▲ Show 20 Lines • Show All 331 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-len2.cpp

// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 2, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 0 \
// RUN: ]}' -- // RUN: }}' --
namespace std { namespace std {
using size_t = decltype(sizeof(int)); using size_t = decltype(sizeof(int));
} // namespace std } // namespace std
#define assert(X) ((void)(X)) #define assert(X) ((void)(X))
void declaration(int Param, int Other); // NO-WARN: No chance to change this function. void declaration(int Param, int Other); // NO-WARN: No chance to change this function.
▲ Show 20 Lines • Show All 411 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-len3.cpp

// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 3}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 3, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 0 \
// RUN: ]}' -- // RUN: }}' --
int add(int Left, int Right) { return Left + Right; } // NO-WARN: Only 2 parameters. int add(int Left, int Right) { return Left + Right; } // NO-WARN: Only 2 parameters.
int magic(int Left, int Right, int X, int Y) { return 0; } int magic(int Left, int Right, int X, int Y) { return 0; }
// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 4 adjacent parameters of 'magic' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 4 adjacent parameters of 'magic' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
// CHECK-MESSAGES: :[[@LINE-2]]:15: note: the first parameter in the range is 'Left' // CHECK-MESSAGES: :[[@LINE-2]]:15: note: the first parameter in the range is 'Left'
// CHECK-MESSAGES: :[[@LINE-3]]:43: note: the last parameter in the range is 'Y' // CHECK-MESSAGES: :[[@LINE-3]]:43: note: the last parameter in the range is 'Y'
Show All 10 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-prefixsuffixname.cpp

// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 2, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 1} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 1 \
// RUN: ]}' -- // RUN: }}' --
namespace std { namespace std {
struct string {}; struct string {};
} // namespace std } // namespace std
class Matrix {}; class Matrix {};
void test1(int Foo, int Bar) {} void test1(int Foo, int Bar) {}
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 2 adjacent parameters of 'test1' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters] // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 2 adjacent parameters of 'test1' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
Show All 38 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-qualifiermixing.cpp

// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 2, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 1}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 1, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 0 \
// RUN: ]}' -- // RUN: }}' --
typedef int MyInt1; typedef int MyInt1;
typedef int MyInt2; typedef int MyInt2;
using CInt = const int; using CInt = const int;
using CMyInt1 = const MyInt1; using CMyInt1 = const MyInt1;
using CMyInt2 = const MyInt2; using CMyInt2 = const MyInt2;
void qualified1(int I, const int CI) {} void qualified1(int I, const int CI) {}
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-relatedness.c

// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 2, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 1}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 1, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 0 \
// RUN: ]}' -- -Wno-strict-prototypes -x c // RUN: }}' -- -Wno-strict-prototypes -x c
int myprint(); int myprint();
int add(int X, int Y); int add(int X, int Y);
void notRelated(int A, int B) {} void notRelated(int A, int B) {}
// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: 2 adjacent parameters of 'notRelated' of similar type ('int') // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: 2 adjacent parameters of 'notRelated' of similar type ('int')
// CHECK-MESSAGES: :[[@LINE-2]]:21: note: the first parameter in the range is 'A' // CHECK-MESSAGES: :[[@LINE-2]]:21: note: the first parameter in the range is 'A'
// CHECK-MESSAGES: :[[@LINE-3]]:28: note: the last parameter in the range is 'B' // CHECK-MESSAGES: :[[@LINE-3]]:28: note: the last parameter in the range is 'B'
Show All 13 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters-relatedness.cpp

// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 2, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 1}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 1, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 0 \
// RUN: ]}' -- // RUN: }}' --
namespace std { namespace std {
template <typename T> template <typename T>
T max(const T &A, const T &B); T max(const T &A, const T &B);
} // namespace std } // namespace std
bool coin(); bool coin();
void f(int); void f(int);
▲ Show 20 Lines • Show All 214 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/easily-swappable-parameters.c

// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \ // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \ // RUN: bugprone-easily-swappable-parameters.MinimumLength: 2, \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterNames: "", \
// RUN: {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: "bool;MyBool;struct U;MAKE_LOGICAL_TYPE(int)"}, \ // RUN: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes: "bool;MyBool;struct U;MAKE_LOGICAL_TYPE(int)", \
// RUN: {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.QualifiersMix: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.ModelImplicitConversions: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \ // RUN: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether: 0, \
// RUN: {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \ // RUN: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold: 0 \
// RUN: ]}' -- -Wno-strict-prototypes -x c // RUN: }}' -- -Wno-strict-prototypes -x c
#define bool _Bool #define bool _Bool
#define true 1 #define true 1
#define false 0 #define false 0
typedef bool MyBool; typedef bool MyBool;
#define TheLogicalType bool #define TheLogicalType bool
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

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

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

clang-tools-extra/test/clang-tidy/checkers/bugprone/implicit-widening-of-multiplication-result-array-subscript-expression.cpp

// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++ // RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++
// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \ // RUN: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources: false \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c // RUN: }}' -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \ // RUN: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources: false \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c++ // RUN: }}' -- -target x86_64-unknown-unknown -x c++
char *t0(char *base, int a, int b) { char *t0(char *base, int a, int b) {
return &base[a * b]; return &base[a * b];
// CHECK-NOTES-ALL: :[[@LINE-1]]:11: warning: result of multiplication in type 'int' is used as a pointer offset after an implicit widening conversion to type 'ptrdiff_t' // CHECK-NOTES-ALL: :[[@LINE-1]]:11: warning: result of multiplication in type 'int' is used as a pointer offset after an implicit widening conversion to type 'ptrdiff_t'
// CHECK-NOTES-ALL: :[[@LINE-2]]:16: note: make conversion explicit to silence this warning // CHECK-NOTES-ALL: :[[@LINE-2]]:16: note: make conversion explicit to silence this warning
// CHECK-NOTES-C: (ptrdiff_t)( ) // CHECK-NOTES-C: (ptrdiff_t)( )
// CHECK-NOTES-CXX: static_cast<ptrdiff_t>( ) // CHECK-NOTES-CXX: static_cast<ptrdiff_t>( )
// CHECK-NOTES-ALL: :[[@LINE-5]]:16: note: perform multiplication in a wider type // CHECK-NOTES-ALL: :[[@LINE-5]]:16: note: perform multiplication in a wider type
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/implicit-widening-of-multiplication-result-int.cpp

// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++ // RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++
// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \ // RUN: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources: false \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c // RUN: }}' -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \ // RUN: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources: false \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c++ // RUN: }}' -- -target x86_64-unknown-unknown -x c++
long t0(int a, int b) { long t0(int a, int b) {
return a * b; return a * b;
// CHECK-NOTES-ALL: :[[@LINE-1]]:10: warning: performing an implicit widening conversion to type 'long' of a multiplication performed in type 'int' // CHECK-NOTES-ALL: :[[@LINE-1]]:10: warning: performing an implicit widening conversion to type 'long' of a multiplication performed in type 'int'
// CHECK-NOTES-ALL: :[[@LINE-2]]:10: note: make conversion explicit to silence this warning // CHECK-NOTES-ALL: :[[@LINE-2]]:10: note: make conversion explicit to silence this warning
// CHECK-NOTES-C: (long)( ) // CHECK-NOTES-C: (long)( )
// CHECK-NOTES-CXX: static_cast<long>( ) // CHECK-NOTES-CXX: static_cast<long>( )
// CHECK-NOTES-ALL: :[[@LINE-5]]:10: note: perform multiplication in a wider type // CHECK-NOTES-ALL: :[[@LINE-5]]:10: note: perform multiplication in a wider type
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/implicit-widening-of-multiplication-result-pointer-offset.cpp

// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++ // RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++
// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \ // RUN: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources: false \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c // RUN: }}' -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \ // RUN: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources: false \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c++ // RUN: }}' -- -target x86_64-unknown-unknown -x c++
char *t0(char *base, int a, int b) { char *t0(char *base, int a, int b) {
return base + a * b; return base + a * b;
// CHECK-NOTES-ALL: :[[@LINE-1]]:10: warning: result of multiplication in type 'int' is used as a pointer offset after an implicit widening conversion to type 'ptrdiff_t' // CHECK-NOTES-ALL: :[[@LINE-1]]:10: warning: result of multiplication in type 'int' is used as a pointer offset after an implicit widening conversion to type 'ptrdiff_t'
// CHECK-NOTES-ALL: :[[@LINE-2]]:17: note: make conversion explicit to silence this warning // CHECK-NOTES-ALL: :[[@LINE-2]]:17: note: make conversion explicit to silence this warning
// CHECK-NOTES-C: (ptrdiff_t)( ) // CHECK-NOTES-C: (ptrdiff_t)( )
// CHECK-NOTES-CXX: static_cast<ptrdiff_t>( ) // CHECK-NOTES-CXX: static_cast<ptrdiff_t>( )
// CHECK-NOTES-ALL: :[[@LINE-5]]:17: note: perform multiplication in a wider type // CHECK-NOTES-ALL: :[[@LINE-5]]:17: note: perform multiplication in a wider type
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/misplaced-widening-cast-explicit-only.cpp

// RUN: %check_clang_tidy %s bugprone-misplaced-widening-cast %t -- -config="{CheckOptions: [{key: bugprone-misplaced-widening-cast.CheckImplicitCasts, value: false}]}" -- // RUN: %check_clang_tidy %s bugprone-misplaced-widening-cast %t -- -config="{CheckOptions: {bugprone-misplaced-widening-cast.CheckImplicitCasts: false}}" --
void func(long arg) {} void func(long arg) {}
void assign(int a, int b) { void assign(int a, int b) {
long l; long l;
l = a * b; l = a * b;
l = (long)(a * b); l = (long)(a * b);
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/misplaced-widening-cast-implicit-enabled.cpp

// RUN: %check_clang_tidy %s bugprone-misplaced-widening-cast %t -- -config="{CheckOptions: [{key: bugprone-misplaced-widening-cast.CheckImplicitCasts, value: true}]}" -- // RUN: %check_clang_tidy %s bugprone-misplaced-widening-cast %t -- -config="{CheckOptions: {bugprone-misplaced-widening-cast.CheckImplicitCasts: true}}" --
void func(long arg) {} void func(long arg) {}
void assign(int a, int b) { void assign(int a, int b) {
long l; long l;
l = a * b; l = a * b;
// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: either cast from 'int' to 'long' is ineffective, or there is loss of precision before the conversion [bugprone-misplaced-widening-cast] // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: either cast from 'int' to 'long' is ineffective, or there is loss of precision before the conversion [bugprone-misplaced-widening-cast]
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/not-null-terminated-result-memcpy-before-safe.c

// RUN: %check_clang_tidy %s bugprone-not-null-terminated-result %t -- \ // RUN: %check_clang_tidy %s bugprone-not-null-terminated-result %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: bugprone-not-null-terminated-result.WantToUseSafeFunctions, \ // RUN: {bugprone-not-null-terminated-result.WantToUseSafeFunction: true}}" \
// RUN: value: true}]}" \
// RUN: -- -std=c11 -I %S/Inputs/not-null-terminated-result // RUN: -- -std=c11 -I %S/Inputs/not-null-terminated-result
#include "not-null-terminated-result-c.h" #include "not-null-terminated-result-c.h"
// The following is not defined therefore the safe functions are unavailable. // The following is not defined therefore the safe functions are unavailable.
// #define __STDC_LIB_EXT1__ 1 // #define __STDC_LIB_EXT1__ 1
#define __STDC_WANT_LIB_EXT1__ 1 #define __STDC_WANT_LIB_EXT1__ 1
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/reserved-identifier-invert.cpp

// RUN: %check_clang_tidy %s bugprone-reserved-identifier %t -- \ // RUN: %check_clang_tidy %s bugprone-reserved-identifier %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: bugprone-reserved-identifier.Invert, value: true}, \ // RUN: bugprone-reserved-identifier.Invert: true, \
// RUN: {key: bugprone-reserved-identifier.AllowedIdentifiers, value: std;reference_wrapper;ref;cref;type;get}, \ // RUN: bugprone-reserved-identifier.AllowedIdentifiers: std;reference_wrapper;ref;cref;type;get, \
// RUN: ]}' -- \ // RUN: }}' -- \
// RUN: -I%S/Inputs/reserved-identifier \ // RUN: -I%S/Inputs/reserved-identifier \
// RUN: -isystem %S/Inputs/reserved-identifier/system // RUN: -isystem %S/Inputs/reserved-identifier/system
namespace std { namespace std {
void __f() {} void __f() {}
void f(); void f();
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/signal-handler-minimal.c

// RUN: %check_clang_tidy %s bugprone-signal-handler %t \ // RUN: %check_clang_tidy %s bugprone-signal-handler %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: bugprone-signal-handler.AsyncSafeFunctionSet, value: "minimal"}]}' \ // RUN: {bugprone-signal-handler.AsyncSafeFunctionSet: "minimal"}}' \
// RUN: -- -isystem %clang_tidy_headers // RUN: -- -isystem %clang_tidy_headers
#include "signal.h" #include "signal.h"
#include "stdlib.h" #include "stdlib.h"
#include "string.h" #include "string.h"
#include "unistd.h" #include "unistd.h"
void handler_bad1(int) { void handler_bad1(int) {
Show All 21 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/signal-handler-posix.c

// RUN: %check_clang_tidy %s bugprone-signal-handler %t \ // RUN: %check_clang_tidy %s bugprone-signal-handler %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: bugprone-signal-handler.AsyncSafeFunctionSet, value: "POSIX"}]}' \ // RUN: {bugprone-signal-handler.AsyncSafeFunctionSet: "POSIX"}}' \
// RUN: -- -isystem %clang_tidy_headers // RUN: -- -isystem %clang_tidy_headers
#include "signal.h" #include "signal.h"
#include "stdlib.h" #include "stdlib.h"
#include "stdio.h" #include "stdio.h"
#include "string.h" #include "string.h"
#include "unistd.h" #include "unistd.h"
Show All 18 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/signed-char-misuse-with-option.cpp

// RUN: %check_clang_tidy %s bugprone-signed-char-misuse %t \ // RUN: %check_clang_tidy %s bugprone-signed-char-misuse %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: bugprone-signed-char-misuse.CharTypdefsToIgnore, value: "sal_Int8;int8_t"}]}' \ // RUN: {bugprone-signed-char-misuse.CharTypdefsToIgnore: "sal_Int8;int8_t"}}' \
// RUN: -- // RUN: --
/////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////
/// Test cases correctly caught by the check. /// Test cases correctly caught by the check.
// Check that a simple test case is still caught. // Check that a simple test case is still caught.
int SimpleAssignment() { int SimpleAssignment() {
signed char CCharacter = -5; signed char CCharacter = -5;
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/sizeof-expression.cpp

// RUN: %check_clang_tidy %s bugprone-sizeof-expression %t -- -config="{CheckOptions: [{key: bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression, value: true}]}" -- // RUN: %check_clang_tidy %s bugprone-sizeof-expression %t -- -config="{CheckOptions: {bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression: true}}" --
class C { class C {
int size() { return sizeof(this); } int size() { return sizeof(this); }
// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: suspicious usage of 'sizeof(this)' // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: suspicious usage of 'sizeof(this)'
}; };
#define LEN 8 #define LEN 8
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/suspicious-enum-usage-strict.cpp

// RUN: %check_clang_tidy %s bugprone-suspicious-enum-usage %t -- -config="{CheckOptions: [{key: bugprone-suspicious-enum-usage.StrictMode, value: true}]}" -- // RUN: %check_clang_tidy %s bugprone-suspicious-enum-usage %t -- -config="{CheckOptions: {bugprone-suspicious-enum-usage.StrictMode: true}}" --
enum A { enum A {
A = 1, A = 1,
B = 2, B = 2,
C = 4, C = 4,
D = 8, D = 8,
E = 16, E = 16,
F = 32, F = 32,
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/suspicious-enum-usage.cpp

// RUN: %check_clang_tidy %s bugprone-suspicious-enum-usage %t -- -config="{CheckOptions: [{key: bugprone-suspicious-enum-usage.StrictMode, value: false}]}" -- // RUN: %check_clang_tidy %s bugprone-suspicious-enum-usage %t -- -config="{CheckOptions: {bugprone-suspicious-enum-usage.StrictMode: false}}" --
enum Empty { enum Empty {
}; };
enum A { enum A {
A = 1, A = 1,
B = 2, B = 2,
C = 4, C = 4,
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/suspicious-string-compare.c

// RUN: %check_clang_tidy %s bugprone-suspicious-string-compare %t -- \ // RUN: %check_clang_tidy %s bugprone-suspicious-string-compare %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: bugprone-suspicious-string-compare.WarnOnImplicitComparison, value: true}, \ // RUN: {bugprone-suspicious-string-compare.WarnOnImplicitComparison: true, \
// RUN: {key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison, value: true}]}' \ // RUN: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison: true}}' \
// RUN: -- -std=c99 // RUN: -- -std=c99
static const char A[] = "abc"; static const char A[] = "abc";
int strcmp(const char *, const char *); int strcmp(const char *, const char *);
int test_warning_patterns(void) { int test_warning_patterns(void) {
if (strcmp(A, "a")) if (strcmp(A, "a"))
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/suspicious-string-compare.cpp

// RUN: %check_clang_tidy %s bugprone-suspicious-string-compare %t -- \ // RUN: %check_clang_tidy %s bugprone-suspicious-string-compare %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: bugprone-suspicious-string-compare.WarnOnImplicitComparison, value: true}, \ // RUN: {bugprone-suspicious-string-compare.WarnOnImplicitComparison: true, \
// RUN: {key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison, value: true}]}' \ // RUN: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison: true}}' \
// RUN: -- // RUN: --
typedef __SIZE_TYPE__ size; typedef __SIZE_TYPE__ size;
struct locale_t { struct locale_t {
void* dummy; void* dummy;
} locale; } locale;
▲ Show 20 Lines • Show All 325 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/too-small-loop-variable.cpp

// RUN: %check_clang_tidy %s bugprone-too-small-loop-variable %t -- \ // RUN: %check_clang_tidy %s bugprone-too-small-loop-variable %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: bugprone-too-small-loop-variable.MagnitudeBitsUpperLimit, \ // RUN: {bugprone-too-small-loop-variable.MagnitudeBitsUpperLimit: 1024}}" \
// RUN: value: 1024}]}" \
// RUN: -- --target=x86_64-linux // RUN: -- --target=x86_64-linux
long size() { return 294967296l; } long size() { return 294967296l; }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// Test cases correctly caught by bugprone-too-small-loop-variable. /// Test cases correctly caught by bugprone-too-small-loop-variable.
void voidBadForLoop() { void voidBadForLoop() {
▲ Show 20 Lines • Show All 243 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/unhandled-self-assignment-warn-only-if-this-has-suspicious-field.cpp

// RUN: %check_clang_tidy %s bugprone-unhandled-self-assignment %t -- \ // RUN: %check_clang_tidy %s bugprone-unhandled-self-assignment %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: bugprone-unhandled-self-assignment.WarnOnlyIfThisHasSuspiciousField, \ // RUN: {bugprone-unhandled-self-assignment.WarnOnlyIfThisHasSuspiciousField: false}}"
// RUN: value: false}]}"
// Classes with pointer field are still caught. // Classes with pointer field are still caught.
class PtrField { class PtrField {
public: public:
PtrField &operator=(const PtrField &object) { PtrField &operator=(const PtrField &object) {
// CHECK-MESSAGES: [[@LINE-1]]:13: warning: operator=() does not handle self-assignment properly [bugprone-unhandled-self-assignment] // CHECK-MESSAGES: [[@LINE-1]]:13: warning: operator=() does not handle self-assignment properly [bugprone-unhandled-self-assignment]
return *this; return *this;
} }
Show All 29 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone/unused-return-value-custom.cpp

// RUN: %check_clang_tidy %s bugprone-unused-return-value %t \ // RUN: %check_clang_tidy %s bugprone-unused-return-value %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: bugprone-unused-return-value.CheckedFunctions, \ // RUN: {bugprone-unused-return-value.CheckedFunctions: \
// RUN: value: "::fun;::ns::Outer::Inner::memFun;::ns::Type::staticFun;::ns::ClassTemplate::memFun;::ns::ClassTemplate::staticFun"}]}' \ // RUN: "::fun;::ns::Outer::Inner::memFun;::ns::Type::staticFun;::ns::ClassTemplate::memFun;::ns::ClassTemplate::staticFun"}}' \
// RUN: -- // RUN: --
namespace std { namespace std {
template <typename T> template <typename T>
T *launder(T *); T *launder(T *);
} // namespace std } // namespace std
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/cert/msc32-c.c

// RUN: %check_clang_tidy %s cert-msc32-c %t -- -config="{CheckOptions: [{key: cert-msc32-c.DisallowedSeedTypes, value: 'some_type,time_t'}]}" -- -std=c99 // RUN: %check_clang_tidy %s cert-msc32-c %t -- -config="{CheckOptions: {cert-msc32-c.DisallowedSeedTypes: 'some_type,time_t'}}" -- -std=c99
void srand(int seed); void srand(int seed);
typedef int time_t; typedef int time_t;
time_t time(time_t *t); time_t time(time_t *t);
void f(void) { void f(void) {
srand(1); srand(1);
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: random number generator seeded with a constant value will generate a predictable sequence of values [cert-msc32-c] // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: random number generator seeded with a constant value will generate a predictable sequence of values [cert-msc32-c]
Show All 18 Lines

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

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

clang-tools-extra/test/clang-tidy/checkers/cert/oop57-cpp.cpp

// RUN: %check_clang_tidy %s cert-oop57-cpp %t -- \ // RUN: %check_clang_tidy %s cert-oop57-cpp %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: cert-oop57-cpp.MemSetNames, value: mymemset}, \ // RUN: {cert-oop57-cpp.MemSetNames: mymemset, \
// RUN: {key: cert-oop57-cpp.MemCpyNames, value: mymemcpy}, \ // RUN: cert-oop57-cpp.MemCpyNames: mymemcpy, \
// RUN: {key: cert-oop57-cpp.MemCmpNames, value: mymemcmp}]}' \ // RUN: cert-oop57-cpp.MemCmpNames: mymemcmp}}' \
// RUN: -- // RUN: --
void mymemset(void *, unsigned char, decltype(sizeof(int))); void mymemset(void *, unsigned char, decltype(sizeof(int)));
void mymemcpy(void *, const void *, decltype(sizeof(int))); void mymemcpy(void *, const void *, decltype(sizeof(int)));
int mymemcmp(const void *, const void *, decltype(sizeof(int))); int mymemcmp(const void *, const void *, decltype(sizeof(int)));
namespace std { namespace std {
void memset(void *, unsigned char, decltype(sizeof(int))); void memset(void *, unsigned char, decltype(sizeof(int)));
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/concurrency/mt-unsafe-glibc.cpp

// RUN: %check_clang_tidy %s concurrency-mt-unsafe %t -- -config='{CheckOptions: [{key: "concurrency-mt-unsafe.FunctionSet", value: "glibc"}]}' // RUN: %check_clang_tidy %s concurrency-mt-unsafe %t -- -config='{CheckOptions: {concurrency-mt-unsafe.FunctionSet: "glibc"}}'
extern unsigned int sleep (unsigned int __seconds); extern unsigned int sleep (unsigned int __seconds);
extern int *gmtime (const int *__timer); extern int *gmtime (const int *__timer);
extern char *dirname (char *__path); extern char *dirname (char *__path);
void foo() { void foo() {
sleep(2); sleep(2);
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function is not thread safe [concurrency-mt-unsafe] // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function is not thread safe [concurrency-mt-unsafe]
::sleep(2); ::sleep(2);
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function is not thread safe [concurrency-mt-unsafe] // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: function is not thread safe [concurrency-mt-unsafe]
dirname(nullptr); dirname(nullptr);
} }

clang-tools-extra/test/clang-tidy/checkers/concurrency/mt-unsafe-posix.cpp

// RUN: %check_clang_tidy %s concurrency-mt-unsafe %t -- -config='{CheckOptions: [{key: "concurrency-mt-unsafe.FunctionSet", value: "posix"}]}' // RUN: %check_clang_tidy %s concurrency-mt-unsafe %t -- -config='{CheckOptions: {concurrency-mt-unsafe.FunctionSet: "posix"}}'
extern unsigned int sleep (unsigned int __seconds); extern unsigned int sleep (unsigned int __seconds);
extern int *gmtime (const int *__timer); extern int *gmtime (const int *__timer);
extern int *gmtime_r (const int *__timer, char*); extern int *gmtime_r (const int *__timer, char*);
extern char *dirname (char *__path); extern char *dirname (char *__path);
void foo() { void foo() {
sleep(2); sleep(2);
Show All 13 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/macro-usage-caps-only.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-macro-usage %t \ // RUN: %check_clang_tidy %s cppcoreguidelines-macro-usage %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: cppcoreguidelines-macro-usage.CheckCapsOnly, value: true}]}' -- // RUN: {cppcoreguidelines-macro-usage.CheckCapsOnly: true}}' --
#ifndef INCLUDE_GUARD #ifndef INCLUDE_GUARD
#define INCLUDE_GUARD #define INCLUDE_GUARD
#define problematic_constant 0 #define problematic_constant 0
// CHECK-MESSAGES: [[@LINE-1]]:9: warning: macro definition does not define the macro name 'problematic_constant' using all uppercase characters // CHECK-MESSAGES: [[@LINE-1]]:9: warning: macro definition does not define the macro name 'problematic_constant' using all uppercase characters
#define problematic_function(x, y) ((a) > (b) ? (a) : (b)) #define problematic_function(x, y) ((a) > (b) ? (a) : (b))
Show All 13 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/macro-usage-command-line-macros.cpp

// RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- -- -D_ZZZ_IM_A_MACRO // RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- -- -D_ZZZ_IM_A_MACRO
// RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: true}]}' -- -D_ZZZ_IM_A_MACRO // RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- -config='{CheckOptions: {cppcoreguidelines-macro-usage.IgnoreCommandLineMacros: true}}' -- -D_ZZZ_IM_A_MACRO
// RUN: %check_clang_tidy -check-suffixes=NORMAL,CL %s cppcoreguidelines-macro-usage %t -- -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: false}]}' -- -D_ZZZ_IM_A_MACRO // RUN: %check_clang_tidy -check-suffixes=NORMAL,CL %s cppcoreguidelines-macro-usage %t -- -config='{CheckOptions: {cppcoreguidelines-macro-usage.IgnoreCommandLineMacros: false}}' -- -D_ZZZ_IM_A_MACRO
// CHECK-MESSAGES-CL: warning: macro '_ZZZ_IM_A_MACRO' used to declare a constant; consider using a 'constexpr' constant // CHECK-MESSAGES-CL: warning: macro '_ZZZ_IM_A_MACRO' used to declare a constant; consider using a 'constexpr' constant
#define PROBLEMATIC_CONSTANT 0 #define PROBLEMATIC_CONSTANT 0
// CHECK-MESSAGES-NORMAL: [[@LINE-1]]:9: warning: macro 'PROBLEMATIC_CONSTANT' used to declare a constant; consider using a 'constexpr' constant // CHECK-MESSAGES-NORMAL: [[@LINE-1]]:9: warning: macro 'PROBLEMATIC_CONSTANT' used to declare a constant; consider using a 'constexpr' constant

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/macro-usage-custom.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-macro-usage %t \ // RUN: %check_clang_tidy %s cppcoreguidelines-macro-usage %t \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: cppcoreguidelines-macro-usage.AllowedRegexp, value: 'DEBUG_*|TEST_*'}]}" -- // RUN: {cppcoreguidelines-macro-usage.AllowedRegexp: 'DEBUG_*|TEST_*'}}" --
#ifndef INCLUDE_GUARD #ifndef INCLUDE_GUARD
#define INCLUDE_GUARD #define INCLUDE_GUARD
#define PROBLEMATIC_CONSTANT 0 #define PROBLEMATIC_CONSTANT 0
// CHECK-MESSAGES: [[@LINE-1]]:9: warning: macro 'PROBLEMATIC_CONSTANT' used to declare a constant; consider using a 'constexpr' constant // CHECK-MESSAGES: [[@LINE-1]]:9: warning: macro 'PROBLEMATIC_CONSTANT' used to declare a constant; consider using a 'constexpr' constant
#define PROBLEMATIC_FUNCTION(x, y) ((a) > (b) ? (a) : (b)) #define PROBLEMATIC_FUNCTION(x, y) ((a) > (b) ? (a) : (b))
Show All 17 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/narrowing-conversions-equivalentbitwidth-option.cpp

// RUN: %check_clang_tidy -check-suffix=DEFAULT %s \ // RUN: %check_clang_tidy -check-suffix=DEFAULT %s \
// RUN: cppcoreguidelines-narrowing-conversions %t -- \ // RUN: cppcoreguidelines-narrowing-conversions %t --
// RUN: -config='{CheckOptions: [ \
// RUN: ]}'
// RUN: %check_clang_tidy -check-suffix=DISABLED %s \ // RUN: %check_clang_tidy -check-suffix=DISABLED %s \
// RUN: cppcoreguidelines-narrowing-conversions %t -- \ // RUN: cppcoreguidelines-narrowing-conversions %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: cppcoreguidelines-narrowing-conversions.WarnOnEquivalentBitWidth, value: 0} \ // RUN: cppcoreguidelines-narrowing-conversions.WarnOnEquivalentBitWidth: 0}}'
// RUN: ]}'
void narrowing_equivalent_bitwidth() { void narrowing_equivalent_bitwidth() {
int i; int i;
unsigned int ui; unsigned int ui;
i = ui; i = ui;
// CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:7: warning: narrowing conversion from 'unsigned int' to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:7: warning: narrowing conversion from 'unsigned int' to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions]
// DISABLED: Warning disabled with WarnOnEquivalentBitWidth=0. // DISABLED: Warning disabled with WarnOnEquivalentBitWidth=0.
Show All 27 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/narrowing-conversions-ignoreconversionfromtypes-option.cpp

// RUN: %check_clang_tidy -check-suffix=DEFAULT %s \ // RUN: %check_clang_tidy -check-suffix=DEFAULT %s \
// RUN: cppcoreguidelines-narrowing-conversions %t -- \ // RUN: cppcoreguidelines-narrowing-conversions %t --
// RUN: -config='{CheckOptions: [ \
// RUN: ]}'
// RUN: %check_clang_tidy -check-suffix=IGNORED %s \ // RUN: %check_clang_tidy -check-suffix=IGNORED %s \
// RUN: cppcoreguidelines-narrowing-conversions %t -- \ // RUN: cppcoreguidelines-narrowing-conversions %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: cppcoreguidelines-narrowing-conversions.IgnoreConversionFromTypes, value: "global_size_t;nested_size_type"} \ // RUN: cppcoreguidelines-narrowing-conversions.IgnoreConversionFromTypes: "global_size_t;nested_size_type" \
// RUN: ]}' // RUN: }}'
// We use global_size_t instead of 'size_t' because windows predefines size_t. // We use global_size_t instead of 'size_t' because windows predefines size_t.
typedef long long global_size_t; typedef long long global_size_t;
struct vector { struct vector {
typedef long long nested_size_type; typedef long long nested_size_type;
global_size_t size() const { return 0; } global_size_t size() const { return 0; }
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/narrowing-conversions-intemplates-option.cpp

// RUN: %check_clang_tidy -check-suffix=DEFAULT %s \ // RUN: %check_clang_tidy -check-suffix=DEFAULT %s \
// RUN: cppcoreguidelines-narrowing-conversions %t -- \ // RUN: cppcoreguidelines-narrowing-conversions %t --
// RUN: -config='{CheckOptions: [ \
// RUN: ]}'
// RUN: %check_clang_tidy -check-suffix=WARN %s \ // RUN: %check_clang_tidy -check-suffix=WARN %s \
// RUN: cppcoreguidelines-narrowing-conversions %t -- \ // RUN: cppcoreguidelines-narrowing-conversions %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: cppcoreguidelines-narrowing-conversions.WarnWithinTemplateInstantiation, value: 1} \ // RUN: cppcoreguidelines-narrowing-conversions.WarnWithinTemplateInstantiation: 1 \
// RUN: ]}' // RUN: }}'
template <typename OrigType> template <typename OrigType>
void assign_in_template(OrigType jj) { void assign_in_template(OrigType jj) {
int ii; int ii;
ii = jj; ii = jj;
// DEFAULT: Warning disabled because WarnWithinTemplateInstantiation=0. // DEFAULT: Warning disabled because WarnWithinTemplateInstantiation=0.
// CHECK-MESSAGES-WARN: :[[@LINE-2]]:8: warning: narrowing conversion from 'long long' to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES-WARN: :[[@LINE-2]]:8: warning: narrowing conversion from 'long long' to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions]
} }
Show All 17 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/narrowing-conversions-narrowinginteger-option.cpp

// RUN: %check_clang_tidy -check-suffix=DEFAULT %s \ // RUN: %check_clang_tidy -check-suffix=DEFAULT %s \
// RUN: cppcoreguidelines-narrowing-conversions %t -- \ // RUN: cppcoreguidelines-narrowing-conversions %t -- \
// RUN: -config='{CheckOptions: [{key: cppcoreguidelines-narrowing-conversions.WarnOnIntegerNarrowingConversion, value: true}]}' // RUN: -config='{CheckOptions: {cppcoreguidelines-narrowing-conversions.WarnOnIntegerNarrowingConversion: true}}'
// RUN: %check_clang_tidy -check-suffix=DISABLED %s \ // RUN: %check_clang_tidy -check-suffix=DISABLED %s \
// RUN: cppcoreguidelines-narrowing-conversions %t -- \ // RUN: cppcoreguidelines-narrowing-conversions %t -- \
// RUN: -config='{CheckOptions: [{key: cppcoreguidelines-narrowing-conversions.WarnOnIntegerNarrowingConversion, value: false}]}' // RUN: -config='{CheckOptions: {cppcoreguidelines-narrowing-conversions.WarnOnIntegerNarrowingConversion: false}}'
void foo(unsigned long long value) { void foo(unsigned long long value) {
int a = value; int a = value;
// CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:11: warning: narrowing conversion from 'unsigned long long' to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:11: warning: narrowing conversion from 'unsigned long long' to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions]
// DISABLED: No warning for integer narrowing conversions when WarnOnIntegerNarrowingConversion = false. // DISABLED: No warning for integer narrowing conversions when WarnOnIntegerNarrowingConversion = false.
long long b = value; long long b = value;
// CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:17: warning: narrowing conversion from 'unsigned long long' to signed type 'long long' is implementation-defined [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:17: warning: narrowing conversion from 'unsigned long long' to signed type 'long long' is implementation-defined [cppcoreguidelines-narrowing-conversions]
// DISABLED: No warning for integer narrowing conversions when WarnOnIntegerNarrowingConversion = false. // DISABLED: No warning for integer narrowing conversions when WarnOnIntegerNarrowingConversion = false.
} }
void casting_float_to_bool_is_still_operational_when_integer_narrowing_is_disabled(float f) { void casting_float_to_bool_is_still_operational_when_integer_narrowing_is_disabled(float f) {
if (f) { if (f) {
// CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:7: warning: narrowing conversion from 'float' to 'bool' [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:7: warning: narrowing conversion from 'float' to 'bool' [cppcoreguidelines-narrowing-conversions]
// CHECK-MESSAGES-DISABLED: :[[@LINE-2]]:7: warning: narrowing conversion from 'float' to 'bool' [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES-DISABLED: :[[@LINE-2]]:7: warning: narrowing conversion from 'float' to 'bool' [cppcoreguidelines-narrowing-conversions]
} }
} }

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/narrowing-conversions-narrowingintegertofloatingpoint-option.cpp

// RUN: %check_clang_tidy -check-suffix=DEFAULT %s \ // RUN: %check_clang_tidy -check-suffix=DEFAULT %s \
// RUN: cppcoreguidelines-narrowing-conversions %t -- \ // RUN: cppcoreguidelines-narrowing-conversions %t -- \
// RUN: -config='{CheckOptions: [{key: cppcoreguidelines-narrowing-conversions.WarnOnIntegerToFloatingPointNarrowingConversion, value: true}]}' // RUN: -config='{CheckOptions: {cppcoreguidelines-narrowing-conversions.WarnOnIntegerToFloatingPointNarrowingConversion: true}}'
// RUN: %check_clang_tidy -check-suffix=DISABLED %s \ // RUN: %check_clang_tidy -check-suffix=DISABLED %s \
// RUN: cppcoreguidelines-narrowing-conversions %t -- \ // RUN: cppcoreguidelines-narrowing-conversions %t -- \
// RUN: -config='{CheckOptions: [{key: cppcoreguidelines-narrowing-conversions.WarnOnIntegerToFloatingPointNarrowingConversion, value: false}]}' // RUN: -config='{CheckOptions: {cppcoreguidelines-narrowing-conversions.WarnOnIntegerToFloatingPointNarrowingConversion: false}}'
void foo(unsigned long long value) { void foo(unsigned long long value) {
double a = value; double a = value;
// CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:14: warning: narrowing conversion from 'unsigned long long' to 'double' [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:14: warning: narrowing conversion from 'unsigned long long' to 'double' [cppcoreguidelines-narrowing-conversions]
// DISABLED: No warning for integer to floating-point narrowing conversions when WarnOnIntegerToFloatingPointNarrowingConversion = false. // DISABLED: No warning for integer to floating-point narrowing conversions when WarnOnIntegerToFloatingPointNarrowingConversion = false.
} }
void floating_point_to_integer_is_still_not_ok(double f) { void floating_point_to_integer_is_still_not_ok(double f) {
int a = f; int a = f;
// CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:11: warning: narrowing conversion from 'double' to 'int' [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:11: warning: narrowing conversion from 'double' to 'int' [cppcoreguidelines-narrowing-conversions]
// CHECK-MESSAGES-DISABLED: :[[@LINE-2]]:11: warning: narrowing conversion from 'double' to 'int' [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES-DISABLED: :[[@LINE-2]]:11: warning: narrowing conversion from 'double' to 'int' [cppcoreguidelines-narrowing-conversions]
} }

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/narrowing-conversions-pedanticmode-option.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-narrowing-conversions %t \ // RUN: %check_clang_tidy %s cppcoreguidelines-narrowing-conversions %t \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: "cppcoreguidelines-narrowing-conversions.PedanticMode", value: true} \ // RUN: cppcoreguidelines-narrowing-conversions.PedanticMode: true}}" \
// RUN: ]}" \
// RUN: -- -target x86_64-unknown-linux -fsigned-char // RUN: -- -target x86_64-unknown-linux -fsigned-char
namespace floats { namespace floats {
void triggers_wrong_constant_type_warning(double d) { void triggers_wrong_constant_type_warning(double d) {
int i = 0.0; int i = 0.0;
// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: constant value should be of type of type 'int' instead of 'double' [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: constant value should be of type of type 'int' instead of 'double' [cppcoreguidelines-narrowing-conversions]
i += 2.0; i += 2.0;
Show All 11 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/narrowing-conversions.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-narrowing-conversions %t \ // RUN: %check_clang_tidy %s cppcoreguidelines-narrowing-conversions %t \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: "cppcoreguidelines-narrowing-conversions.WarnOnFloatingPointNarrowingConversion", value: false}, \ // RUN: cppcoreguidelines-narrowing-conversions.WarnOnFloatingPointNarrowingConversion: false}}" \
// RUN: ]}" \
// RUN: -- -target x86_64-unknown-linux -fsigned-char // RUN: -- -target x86_64-unknown-linux -fsigned-char
float ceil(float); float ceil(float);
namespace std { namespace std {
double ceil(double); double ceil(double);
long double floor(long double); long double floor(long double);
} // namespace std } // namespace std
▲ Show 20 Lines • Show All 347 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/no-malloc-custom.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-no-malloc %t \ // RUN: %check_clang_tidy %s cppcoreguidelines-no-malloc %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: cppcoreguidelines-no-malloc.Allocations, value: "::malloc;::align_malloc;::calloc"},\ // RUN: {cppcoreguidelines-no-malloc.Allocations: "::malloc;::align_malloc;::calloc",\
// RUN: {key: cppcoreguidelines-no-malloc.Reallocations, value: "::realloc;::align_realloc"},\ // RUN: cppcoreguidelines-no-malloc.Reallocations: "::realloc;::align_realloc",\
// RUN: {key: cppcoreguidelines-no-malloc.Deallocations, value: "::free;::align_free"}]}' \ // RUN: cppcoreguidelines-no-malloc.Deallocations: "::free;::align_free"}}' \
// RUN: -- // RUN: --
using size_t = __SIZE_TYPE__; using size_t = __SIZE_TYPE__;
void *malloc(size_t size); void *malloc(size_t size);
void *align_malloc(size_t size, unsigned short alignment); void *align_malloc(size_t size, unsigned short alignment);
void *calloc(size_t num, size_t size); void *calloc(size_t num, size_t size);
void *realloc(void *ptr, size_t size); void *realloc(void *ptr, size_t size);
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/no-malloc-no-functions.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-no-malloc %t \ // RUN: %check_clang_tidy %s cppcoreguidelines-no-malloc %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: cppcoreguidelines-no-malloc.Allocations, value: "::malloc"},\ // RUN: {cppcoreguidelines-no-malloc.Allocations: "::malloc",\
// RUN: {key: cppcoreguidelines-no-malloc.Reallocations, value: ""},\ // RUN: cppcoreguidelines-no-malloc.Reallocations: "",\
// RUN: {key: cppcoreguidelines-no-malloc.Deallocations, value: ""}]}' \ // RUN: cppcoreguidelines-no-malloc.Deallocations: ""}}' \
// RUN: -- // RUN: --
// Just ensure, the check will not crash, when no functions shall be checked. // Just ensure, the check will not crash, when no functions shall be checked.
using size_t = __SIZE_TYPE__; using size_t = __SIZE_TYPE__;
void *malloc(size_t size); void *malloc(size_t size);
void malloced_array() { void malloced_array() {
int *array0 = (int *)malloc(sizeof(int) * 20); int *array0 = (int *)malloc(sizeof(int) * 20);
// CHECK-MESSAGES: :[[@LINE-1]]:24: warning: do not manage memory manually; consider a container or a smart pointer [cppcoreguidelines-no-malloc] // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: do not manage memory manually; consider a container or a smart pointer [cppcoreguidelines-no-malloc]
} }

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

// RUN: %check_clang_tidy %s cppcoreguidelines-owning-memory %t \ // RUN: %check_clang_tidy %s cppcoreguidelines-owning-memory %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: cppcoreguidelines-owning-memory.LegacyResourceProducers, value: "::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile"}, \ // RUN: {cppcoreguidelines-owning-memory.LegacyResourceProducers: "::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile", \
// RUN: {key: cppcoreguidelines-owning-memory.LegacyResourceConsumers, value: "::free;::realloc;::freopen;::fclose"}]}' \ // RUN: cppcoreguidelines-owning-memory.LegacyResourceConsumers: "::free;::realloc;::freopen;::fclose"}}' \
// RUN: -- -nostdlib -nostdinc++ // RUN: -- -nostdlib -nostdinc++
namespace gsl { namespace gsl {
template <class T> template <class T>
using owner = T; using owner = T;
} // namespace gsl } // namespace gsl
extern "C" { extern "C" {
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/prefer-member-initializer-modernize-use-default-member-init-assignment.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-prefer-member-initializer,modernize-use-default-member-init %t -- \ // RUN: %check_clang_tidy %s cppcoreguidelines-prefer-member-initializer,modernize-use-default-member-init %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-default-member-init.UseAssignment, value: true}]}" // RUN: -config="{CheckOptions: {modernize-use-default-member-init.UseAssignment: true}}"
class Simple1 { class Simple1 {
int n; int n;
// CHECK-FIXES: int n = 0; // CHECK-FIXES: int n = 0;
double x; double x;
// CHECK-FIXES: double x = 0.0; // CHECK-FIXES: double x = 0.0;
public: public:
Show All 21 Lines

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

// RUN: %check_clang_tidy %s cppcoreguidelines-pro-bounds-constant-array-index %t -- \ // 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"}]}' // RUN: -config='{CheckOptions: {cppcoreguidelines-pro-bounds-constant-array-index.GslHeader: "dir1/gslheader.h"}}'
// CHECK-FIXES: #include "dir1/gslheader.h" // CHECK-FIXES: #include "dir1/gslheader.h"
typedef __SIZE_TYPE__ size_t; typedef __SIZE_TYPE__ size_t;
namespace std { namespace std {
template<typename T, size_t N> template<typename T, size_t N>
struct array { struct array {
T& operator[](size_t n); T& operator[](size_t n);
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init %t -- -config="{CheckOptions: [{key: "cppcoreguidelines-pro-type-member-init.UseAssignment", value: true}]}" -- -fsigned-char // RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init %t -- -config="{CheckOptions: {cppcoreguidelines-pro-type-member-init.UseAssignment: true}}" -- -fsigned-char
struct T { struct T {
int i; int i;
}; };
struct S { struct S {
bool b; bool b;
// CHECK-FIXES: bool b = false; // CHECK-FIXES: bool b = false;
Show All 31 Lines

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

// RUN: %check_clang_tidy %s \ // RUN: %check_clang_tidy %s \
// RUN: cppcoreguidelines-pro-type-member-init %t \ // RUN: cppcoreguidelines-pro-type-member-init %t \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: cppcoreguidelines-pro-type-member-init.IgnoreArrays, value: true} ]}" // RUN: {cppcoreguidelines-pro-type-member-init.IgnoreArrays: true}}"
typedef int TypedefArray[4]; typedef int TypedefArray[4];
using UsingArray = int[4]; using UsingArray = int[4];
struct HasArrayMember { struct HasArrayMember {
HasArrayMember() {} HasArrayMember() {}
// CHECK-MESSAGES: warning: constructor does not initialize these fields: Number // CHECK-MESSAGES: warning: constructor does not initialize these fields: Number
UsingArray U; UsingArray U;
TypedefArray T; TypedefArray T;
int RawArray[4]; int RawArray[4];
int Number; int Number;
}; };

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/special-member-functions-allow-missing-move-when-copy-is-deleted.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t -- -config="{CheckOptions: [{key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctionsWhenCopyIsDeleted, value: true}]}" -- // RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t -- -config="{CheckOptions: {cppcoreguidelines-special-member-functions.AllowMissingMoveFunctionsWhenCopyIsDeleted: true}}" --
class DefinesEverything { class DefinesEverything {
DefinesEverything(const DefinesEverything &); DefinesEverything(const DefinesEverything &);
DefinesEverything(DefinesEverything &&); DefinesEverything(DefinesEverything &&);
DefinesEverything &operator=(const DefinesEverything &); DefinesEverything &operator=(const DefinesEverything &);
DefinesEverything &operator=(DefinesEverything &&); DefinesEverything &operator=(DefinesEverything &&);
~DefinesEverything(); ~DefinesEverything();
}; };
Show All 40 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/special-member-functions-relaxed.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t -- -config="{CheckOptions: [{key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctions, value: true}, {key: cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor, value: true}]}" -- // RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t -- -config="{CheckOptions: {cppcoreguidelines-special-member-functions.AllowMissingMoveFunctions: true, cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor: true}}" --
class DefinesDestructor { class DefinesDestructor {
~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] // 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 DefinesDefaultedDestructor { class DefinesDefaultedDestructor {
~DefinesDefaultedDestructor() = default; ~DefinesDefaultedDestructor() = default;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

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

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

clang-tools-extra/test/clang-tidy/checkers/hicpp/multiway-paths-covered-else.cpp

// RUN: %check_clang_tidy %s hicpp-multiway-paths-covered %t \ // RUN: %check_clang_tidy %s hicpp-multiway-paths-covered %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: hicpp-multiway-paths-covered.WarnOnMissingElse, value: true}]}'\ // RUN: {hicpp-multiway-paths-covered.WarnOnMissingElse: true}}'\
// RUN: -- // RUN: --
enum OS { Mac, enum OS { Mac,
Windows, Windows,
Linux }; Linux };
void problematic_if(int i, enum OS os) { void problematic_if(int i, enum OS os) {
if (i > 0) { if (i > 0) {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s hicpp-signed-bitwise %t -- \ // RUN: %check_clang_tidy %s hicpp-signed-bitwise %t -- \
// RUN: -config="{CheckOptions: [{key: hicpp-signed-bitwise.IgnorePositiveIntegerLiterals, value: true }]}" \ // RUN: -config="{CheckOptions: {hicpp-signed-bitwise.IgnorePositiveIntegerLiterals: true}}" \
// RUN: -- -std=c++11 // RUN: -- -std=c++11
void examples() { void examples() {
unsigned UValue = 40u; unsigned UValue = 40u;
unsigned URes; unsigned URes;
URes = UValue & 1u; //Ok URes = UValue & 1u; //Ok
URes = UValue & -1; URes = UValue & -1;
Show All 23 Lines

clang-tools-extra/test/clang-tidy/checkers/misc/non-private-member-variables-in-classes.cpp

// RUN: %check_clang_tidy -check-suffixes=PUBLIC,NONPRIVATE,PROTECTED %s misc-non-private-member-variables-in-classes %t // RUN: %check_clang_tidy -check-suffixes=PUBLIC,NONPRIVATE,PROTECTED %s misc-non-private-member-variables-in-classes %t
// RUN: %check_clang_tidy -check-suffixes=PUBLIC,NONPRIVATE,PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: false}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: false}]}' -- // RUN: %check_clang_tidy -check-suffixes=PUBLIC,NONPRIVATE,PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: {misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables: false, misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic: false}}' --
// RUN: %check_clang_tidy -check-suffixes=PUBLIC,PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: false}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: true}]}' -- // RUN: %check_clang_tidy -check-suffixes=PUBLIC,PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: {misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables: false, misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic: true}}' --
// RUN: %check_clang_tidy -check-suffixes=PUBLIC,PROTECTED %s cppcoreguidelines-non-private-member-variables-in-classes %t -- -- // RUN: %check_clang_tidy -check-suffixes=PUBLIC,PROTECTED %s cppcoreguidelines-non-private-member-variables-in-classes %t -- --
// RUN: %check_clang_tidy -check-suffixes=PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: true}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: false}]}' -- // RUN: %check_clang_tidy -check-suffixes=PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: {misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables: true, misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic: false}}' --
// RUN: %check_clang_tidy -check-suffixes=PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: true}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: true}]}' -- // RUN: %check_clang_tidy -check-suffixes=PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: {misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables: true, misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic: true}}' --
//----------------------------------------------------------------------------// //----------------------------------------------------------------------------//
// Only data, do not warn // Only data, do not warn
struct S0 { struct S0 {
int S0_v0; int S0_v0;
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/misc/unused-parameters-strict.cpp

// RUN: %check_clang_tidy %s misc-unused-parameters %t -- \ // RUN: %check_clang_tidy %s misc-unused-parameters %t -- \
// RUN: -config="{CheckOptions: [{key: StrictMode, value: true}]}" -- // RUN: -config="{CheckOptions: {StrictMode: true}}" --
// Warn on empty function bodies in StrictMode. // Warn on empty function bodies in StrictMode.
namespace strict_mode { namespace strict_mode {
void f(int foo) {} void f(int foo) {}
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'foo' is unused [misc-unused-parameters] // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'foo' is unused [misc-unused-parameters]
// CHECK-FIXES: {{^}}void f(int /*foo*/) {}{{$}} // CHECK-FIXES: {{^}}void f(int /*foo*/) {}{{$}}
class E { class E {
int i; int i;
Show All 19 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-bind-permissive-parameter-list.cpp

// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-avoid-bind %t -- \ // RUN: %check_clang_tidy -std=c++14-or-later %s modernize-avoid-bind %t -- \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: modernize-avoid-bind.PermissiveParameterList, value: true}]}" -- // RUN: modernize-avoid-bind.PermissiveParameterList: true}}" --
namespace std { namespace std {
inline namespace impl { inline namespace impl {
template <class Fp, class... Arguments> template <class Fp, class... Arguments>
class bind_rt {}; class bind_rt {};
template <class Fp, class... Arguments> template <class Fp, class... Arguments>
bind_rt<Fp, Arguments...> bind(Fp &&, Arguments &&...); bind_rt<Fp, Arguments...> bind(Fp &&, Arguments &&...);
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize/deprecated-headers-extern-c.cpp

// Copy the 'mylib.h' to a directory under the build directory. This is // Copy the 'mylib.h' to a directory under the build directory. This is
// required, since the relative order of the emitted diagnostics depends on the // required, since the relative order of the emitted diagnostics depends on the
// absolute file paths which is sorted by clang-tidy prior emitting. // absolute file paths which is sorted by clang-tidy prior emitting.
// //
// RUN: mkdir -p %t/sys && mkdir -p %t/usr \ // RUN: mkdir -p %t/sys && mkdir -p %t/usr \
// RUN: && cp %S/Inputs/deprecated-headers/mysystemlib.h %t/sys/mysystemlib.h \ // RUN: && cp %S/Inputs/deprecated-headers/mysystemlib.h %t/sys/mysystemlib.h \
// RUN: && cp %S/Inputs/deprecated-headers/mylib.h %t/usr/mylib.h // RUN: && cp %S/Inputs/deprecated-headers/mylib.h %t/usr/mylib.h
// RUN: %check_clang_tidy -std=c++11 %s modernize-deprecated-headers %t \ // RUN: %check_clang_tidy -std=c++11 %s modernize-deprecated-headers %t \
// RUN: -check-suffixes=DEFAULT \ // RUN: -check-suffixes=DEFAULT \
// RUN: --header-filter='.*' --system-headers \ // RUN: --header-filter='.*' --system-headers \
// RUN: -- -I %t/usr -isystem %t/sys -isystem %S/Inputs/deprecated-headers // RUN: -- -I %t/usr -isystem %t/sys -isystem %S/Inputs/deprecated-headers
// RUN: %check_clang_tidy -std=c++11 %s modernize-deprecated-headers %t \ // RUN: %check_clang_tidy -std=c++11 %s modernize-deprecated-headers %t \
// RUN: -check-suffixes=DEFAULT,CHECK-HEADER-FILE \ // RUN: -check-suffixes=DEFAULT,CHECK-HEADER-FILE \
// RUN: -config="{CheckOptions: [{key: modernize-deprecated-headers.CheckHeaderFile, value: 'true'}]}" \ // RUN: -config="{CheckOptions: {modernize-deprecated-headers.CheckHeaderFile: 'true'}}" \
// RUN: --header-filter='.*' --system-headers \ // RUN: --header-filter='.*' --system-headers \
// RUN: -- -I %t/usr -isystem %t/sys -isystem %S/Inputs/deprecated-headers // RUN: -- -I %t/usr -isystem %t/sys -isystem %S/Inputs/deprecated-headers
// REQUIRES: system-linux // REQUIRES: system-linux
#define EXTERN_C extern "C" #define EXTERN_C extern "C"
extern "C++" { extern "C++" {
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s modernize-loop-convert %t -- \ // RUN: %check_clang_tidy %s modernize-loop-convert %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-loop-convert.NamingStyle, value: 'camelBack'}]}" \ // RUN: -config="{CheckOptions: {modernize-loop-convert.NamingStyle: 'camelBack'}}" \
// RUN: -- -I %S/Inputs/loop-convert // RUN: -- -I %S/Inputs/loop-convert
#include "structures.h" #include "structures.h"
const int n = 10; const int n = 10;
int arr[n]; int arr[n];
int nums[n]; int nums[n];
Show All 23 Lines

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

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

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

// RUN: %check_clang_tidy -std=c++20 -check-suffixes=,RANGES %s modernize-loop-convert %t // RUN: %check_clang_tidy -std=c++20 -check-suffixes=,RANGES %s modernize-loop-convert %t
// RUN: %check_clang_tidy -check-suffixes=,CUSTOM,CUSTOM-NO-SYS %s modernize-loop-convert %t -- \ // RUN: %check_clang_tidy -check-suffixes=,CUSTOM,CUSTOM-NO-SYS %s modernize-loop-convert %t -- \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: modernize-loop-convert.MakeReverseRangeFunction, value: 'llvm::reverse'}, \ // RUN: modernize-loop-convert.MakeReverseRangeFunction: 'llvm::reverse', \
// RUN: {key: modernize-loop-convert.MakeReverseRangeHeader, value: 'llvm/ADT/STLExtras.h'}]}" // RUN: modernize-loop-convert.MakeReverseRangeHeader: 'llvm/ADT/STLExtras.h'}}"
// RUN: %check_clang_tidy -check-suffixes=,CUSTOM,CUSTOM-SYS %s modernize-loop-convert %t -- \ // RUN: %check_clang_tidy -check-suffixes=,CUSTOM,CUSTOM-SYS %s modernize-loop-convert %t -- \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: modernize-loop-convert.MakeReverseRangeFunction, value: 'llvm::reverse'}, \ // RUN: modernize-loop-convert.MakeReverseRangeFunction: 'llvm::reverse', \
// RUN: {key: modernize-loop-convert.MakeReverseRangeHeader, value: '<llvm/ADT/STLExtras.h>'}]}" // RUN: modernize-loop-convert.MakeReverseRangeHeader: '<llvm/ADT/STLExtras.h>'}}"
// RUN: %check_clang_tidy -check-suffixes=,CUSTOM,CUSTOM-NO-HEADER %s modernize-loop-convert %t -- \ // RUN: %check_clang_tidy -check-suffixes=,CUSTOM,CUSTOM-NO-HEADER %s modernize-loop-convert %t -- \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: modernize-loop-convert.MakeReverseRangeFunction, value: 'llvm::reverse'}]}" // RUN: modernize-loop-convert.MakeReverseRangeFunction: 'llvm::reverse'}}"
// Ensure the check doesn't transform reverse loops when not in c++20 mode or // Ensure the check doesn't transform reverse loops when not in c++20 mode or
// when UseCxx20ReverseRanges has been disabled // when UseCxx20ReverseRanges has been disabled
// RUN: clang-tidy %s -checks=-*,modernize-loop-convert -- -std=c++17 | count 0 // RUN: clang-tidy %s -checks=-*,modernize-loop-convert -- -std=c++17 | count 0
// RUN: clang-tidy %s -checks=-*,modernize-loop-convert -config="{CheckOptions: \ // RUN: clang-tidy %s -checks=-*,modernize-loop-convert -config="{CheckOptions: \
// RUN: [{key: modernize-loop-convert.UseCxx20ReverseRanges, value: 'false'}] \ // RUN: {modernize-loop-convert.UseCxx20ReverseRanges: 'false'} \
// RUN: }" -- -std=c++20 | count 0 // RUN: }" -- -std=c++20 | count 0
// Ensure we get a warning if we supply the header argument without the // Ensure we get a warning if we supply the header argument without the
// function argument. // function argument.
// RUN: clang-tidy %s -checks=-*,modernize-loop-convert -config="{CheckOptions: [ \ // RUN: clang-tidy %s -checks=-*,modernize-loop-convert -config="{CheckOptions: { \
// RUN: {key: modernize-loop-convert.MakeReverseRangeHeader, value: 'llvm/ADT/STLExtras.h'}]}" \ // RUN: modernize-loop-convert.MakeReverseRangeHeader: 'llvm/ADT/STLExtras.h'}}" \
// RUN: -- -std=c++17 2>&1 \ // RUN: -- -std=c++17 2>&1 \
// RUN: | FileCheck %s -check-prefix=CHECK-HEADER-NO-FUNC \ // RUN: | FileCheck %s -check-prefix=CHECK-HEADER-NO-FUNC \
// RUN: -implicit-check-not="{{warning|error}}:" // RUN: -implicit-check-not="{{warning|error}}:"
// CHECK-HEADER-NO-FUNC: warning: modernize-loop-convert: 'MakeReverseRangeHeader' is set but 'MakeReverseRangeFunction' is not, disabling reverse loop transformation // CHECK-HEADER-NO-FUNC: warning: modernize-loop-convert: 'MakeReverseRangeHeader' is set but 'MakeReverseRangeFunction' is not, disabling reverse loop transformation
// Make sure appropiate headers are included // Make sure appropiate headers are included
// CHECK-FIXES-RANGES: #include <ranges> // CHECK-FIXES-RANGES: #include <ranges>
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

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

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

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

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

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

// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-make-unique %t -- \ // RUN: %check_clang_tidy -std=c++14-or-later %s modernize-make-unique %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: modernize-make-unique.IgnoreDefaultInitialization, \ // RUN: {modernize-make-unique.IgnoreDefaultInitialization: \
// RUN: value: 'false'}] \ // RUN: 'false'}} \
// RUN: }" \ // RUN: }" \
// RUN: -- -I %S/Inputs/smart-ptr // RUN: -- -I %S/Inputs/smart-ptr
#include "initializer_list.h" #include "initializer_list.h"
#include "unique_ptr.h" #include "unique_ptr.h"
// CHECK-FIXES: #include <memory> // CHECK-FIXES: #include <memory>
void basic() { void basic() {
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

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

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

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

// RUN: %check_clang_tidy -std=c++14-or-later %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: false}]}" \ // RUN: -config="{CheckOptions: {modernize-make-unique.IgnoreMacros: false}}" \
// RUN: -- -I %S/Inputs/smart-ptr // RUN: -- -I %S/Inputs/smart-ptr
#include "unique_ptr.h" #include "unique_ptr.h"
class Foo {}; class Foo {};
class Bar {}; class Bar {};
#define DEFINE(...) __VA_ARGS__ #define DEFINE(...) __VA_ARGS__
// CHECK-FIXES: {{^}}#define DEFINE(...) __VA_ARGS__{{$}} // CHECK-FIXES: {{^}}#define DEFINE(...) __VA_ARGS__{{$}}
Show All 18 Lines

clang-tools-extra/test/clang-tidy/checkers/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: true}]}' // RUN: %check_clang_tidy %s modernize-raw-string-literal %t -- -config='{CheckOptions: {modernize-raw-string-literal.DelimiterStem: "str", modernize-raw-string-literal.ReplaceShorterLiterals: true}}'
char const *const ContainsSentinel{"who\\ops)\""}; char const *const ContainsSentinel{"who\\ops)\""};
// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: {{.*}} can be written as a raw string literal // 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"};{{$}} // CHECK-FIXES: {{^}}char const *const ContainsSentinel{R"str(who\ops)")str"};{{$}}
//char const *const ContainsDelim{"whoops)\")lit\""}; //char const *const ContainsDelim{"whoops)\")lit\""};
// CHECK-XMESSAGES: :[[@LINE-1]]:33: warning: {{.*}} can be written as a raw string literal // 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"};{{$}} // CHECK-XFIXES: {{^}}char const *const ContainsDelim{R"lit1(whoops)")lit")lit1"};{{$}}

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

// RUN: %check_clang_tidy %s modernize-raw-string-literal %t -- -config="{CheckOptions: [{key: modernize-raw-string-literal.ReplaceShorterLiterals, value: true}]}" // RUN: %check_clang_tidy %s modernize-raw-string-literal %t -- -config="{CheckOptions: {modernize-raw-string-literal.ReplaceShorterLiterals: true}}"
char const *const BackSlash("goink\\frob"); 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-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)");{{$}} // CHECK-FIXES: {{^}}char const *const BackSlash(R"(goink\frob)");{{$}}
char const *const PlainLiteral("plain literal"); char const *const PlainLiteral("plain literal");
// Non-printable ASCII characters. // Non-printable ASCII characters.
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize/replace-disallow-copy-and-assign-macro.cpp

// RUN: %check_clang_tidy -format-style=LLVM -check-suffix=DEFAULT %s \ // RUN: %check_clang_tidy -format-style=LLVM -check-suffix=DEFAULT %s \
// RUN: modernize-replace-disallow-copy-and-assign-macro %t // RUN: modernize-replace-disallow-copy-and-assign-macro %t
// RUN: %check_clang_tidy -format-style=LLVM -check-suffix=DIFFERENT-NAME %s \ // RUN: %check_clang_tidy -format-style=LLVM -check-suffix=DIFFERENT-NAME %s \
// RUN: modernize-replace-disallow-copy-and-assign-macro %t \ // RUN: modernize-replace-disallow-copy-and-assign-macro %t \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: modernize-replace-disallow-copy-and-assign-macro.MacroName, \ // RUN: modernize-replace-disallow-copy-and-assign-macro.MacroName: \
// RUN: value: MY_MACRO_NAME}]}" // RUN: MY_MACRO_NAME}}"
// RUN: %check_clang_tidy -format-style=LLVM -check-suffix=FINALIZE %s \ // RUN: %check_clang_tidy -format-style=LLVM -check-suffix=FINALIZE %s \
// RUN: modernize-replace-disallow-copy-and-assign-macro %t \ // RUN: modernize-replace-disallow-copy-and-assign-macro %t \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: modernize-replace-disallow-copy-and-assign-macro.MacroName, \ // RUN: modernize-replace-disallow-copy-and-assign-macro.MacroName: \
// RUN: value: DISALLOW_COPY_AND_ASSIGN_FINALIZE}]}" // RUN: DISALLOW_COPY_AND_ASSIGN_FINALIZE}}"
// RUN: clang-tidy %s -checks="-*,modernize-replace-disallow-copy-and-assign-macro" \ // RUN: clang-tidy %s -checks="-*,modernize-replace-disallow-copy-and-assign-macro" \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: modernize-replace-disallow-copy-and-assign-macro.MacroName, \ // RUN: modernize-replace-disallow-copy-and-assign-macro.MacroName: \
// RUN: value: DISALLOW_COPY_AND_ASSIGN_MORE_AGUMENTS}]}" -- -Wno-extra-semi | count 0 // RUN: DISALLOW_COPY_AND_ASSIGN_MORE_AGUMENTS}}" -- -Wno-extra-semi | count 0
// RUN: clang-tidy %s -checks="-*,modernize-replace-disallow-copy-and-assign-macro" \ // RUN: clang-tidy %s -checks="-*,modernize-replace-disallow-copy-and-assign-macro" \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: modernize-replace-disallow-copy-and-assign-macro.MacroName, \ // RUN: modernize-replace-disallow-copy-and-assign-macro.MacroName: \
// RUN: value: DISALLOW_COPY_AND_ASSIGN_NEEDS_PREEXPANSION}]}" -- -Wno-extra-semi | count 0 // RUN: DISALLOW_COPY_AND_ASSIGN_NEEDS_PREEXPANSION}}" -- -Wno-extra-semi | count 0
// Note: the last two tests expect no diagnostics, but FileCheck cannot handle // Note: the last two tests expect no diagnostics, but FileCheck cannot handle
// that, hence the use of | count 0. // that, hence the use of | count 0.
#define DISALLOW_COPY_AND_ASSIGN(TypeName) #define DISALLOW_COPY_AND_ASSIGN(TypeName)
class TestClass1 { class TestClass1 {
private: private:
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s modernize-use-auto %t -- \ // RUN: %check_clang_tidy %s modernize-use-auto %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 'true'} , {key: modernize-use-auto.MinTypeNameLength, value: '0'}]}" \ // RUN: -config="{CheckOptions: {modernize-use-auto.RemoveStars: 'true' , modernize-use-auto.MinTypeNameLength: '0'}}" \
// RUN: -- -frtti // RUN: -- -frtti
struct A { struct A {
virtual ~A() {} virtual ~A() {}
}; };
struct B : public A {}; struct B : public A {};
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s modernize-use-auto %t -- \ // RUN: %check_clang_tidy %s modernize-use-auto %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-auto.MinTypeNameLength, value: '0'}]}" \ // RUN: -config="{CheckOptions: {modernize-use-auto.MinTypeNameLength: '0'}}" \
// RUN: -- -I %S/Inputs/use-auto -frtti // RUN: -- -I %S/Inputs/use-auto -frtti
struct A { struct A {
virtual ~A() {} virtual ~A() {}
}; };
struct B : public A {}; struct B : public A {};
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/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: false}, {key: modernize-use-auto.MinTypeNameLength, value: 0}]}" -- -frtti // RUN: %check_clang_tidy -check-suffix=0-0 %s modernize-use-auto %t -- -config="{CheckOptions: {modernize-use-auto.RemoveStars: false, modernize-use-auto.MinTypeNameLength: 0}}" -- -frtti
// RUN: %check_clang_tidy -check-suffix=0-8 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: false}, {key: modernize-use-auto.MinTypeNameLength, value: 8}]}" -- -frtti // RUN: %check_clang_tidy -check-suffix=0-8 %s modernize-use-auto %t -- -config="{CheckOptions: {modernize-use-auto.RemoveStars: false, modernize-use-auto.MinTypeNameLength: 8}}" -- -frtti
// RUN: %check_clang_tidy -check-suffix=1-0 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: true}, {key: modernize-use-auto.MinTypeNameLength, value: 0}]}" -- -frtti // RUN: %check_clang_tidy -check-suffix=1-0 %s modernize-use-auto %t -- -config="{CheckOptions: {modernize-use-auto.RemoveStars: true, modernize-use-auto.MinTypeNameLength: 0}}" -- -frtti
// RUN: %check_clang_tidy -check-suffix=1-8 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: true}, {key: modernize-use-auto.MinTypeNameLength, value: 8}]}" -- -frtti // RUN: %check_clang_tidy -check-suffix=1-8 %s modernize-use-auto %t -- -config="{CheckOptions: {modernize-use-auto.RemoveStars: true, modernize-use-auto.MinTypeNameLength: 8}}" -- -frtti
template <class T> extern T foo(); template <class T> extern T foo();
template <class T> struct P { explicit P(T t) : t_(t) {} T t_;}; 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_ptr();
template <class T> P<T> &foo_ref(); template <class T> P<T> &foo_ref();
int bar() { int bar() {
{ {
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

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

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

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

// RUN: %check_clang_tidy %s modernize-use-auto %t -- \ // RUN: %check_clang_tidy %s modernize-use-auto %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-auto.MinTypeNameLength, value: '0'}]}" \ // RUN: -config="{CheckOptions: {modernize-use-auto.MinTypeNameLength: '0'}}" \
// RUN: -- -frtti // RUN: -- -frtti
class MyType {}; class MyType {};
class MyDerivedType : public MyType {}; class MyDerivedType : public MyType {};
// FIXME: the replacement sometimes results in two consecutive spaces after // FIXME: the replacement sometimes results in two consecutive spaces after
// the word 'auto' (due to the presence of spaces at both sides of '*'). // the word 'auto' (due to the presence of spaces at both sides of '*').
▲ Show 20 Lines • Show All 100 Lines • Show Last 20 Lines

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

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

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

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

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

// RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- \ // RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-default-member-init.UseAssignment, value: true}]}" // RUN: -config="{CheckOptions: {modernize-use-default-member-init.UseAssignment: true}}"
struct S { struct S {
}; };
struct PositiveValueChar { struct PositiveValueChar {
PositiveValueChar() : c0(), c1()/*, c2(), c3()*/ {} PositiveValueChar() : c0(), c1()/*, c2(), c3()*/ {}
// CHECK-FIXES: PositiveValueChar() {} // CHECK-FIXES: PositiveValueChar() {}
const char c0; const char c0;
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

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

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

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

// RUN: %check_clang_tidy %s modernize-use-emplace %t -- \ // RUN: %check_clang_tidy %s modernize-use-emplace %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: modernize-use-emplace.IgnoreImplicitConstructors, \ // RUN: {modernize-use-emplace.IgnoreImplicitConstructors: \
// RUN: value: true}] \ // RUN: true}}"
// RUN: }"
namespace std { namespace std {
template <typename> template <typename>
class initializer_list class initializer_list
{ {
public: public:
initializer_list() noexcept {} initializer_list() noexcept {}
}; };
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

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

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

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

// RUN: %check_clang_tidy %s modernize-use-equals-default %t -- \ // RUN: %check_clang_tidy %s modernize-use-equals-default %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-equals-default.IgnoreMacros, value: false}]}" \ // RUN: -config="{CheckOptions: {modernize-use-equals-default.IgnoreMacros: false}}" \
// RUN: -- -fno-delayed-template-parsing -fexceptions // RUN: -- -fno-delayed-template-parsing -fexceptions
// Out of line definition. // Out of line definition.
struct OL { struct OL {
OL(const OL &); OL(const OL &);
OL &operator=(const OL &); OL &operator=(const OL &);
int Field; int Field;
}; };
▲ Show 20 Lines • Show All 497 Lines • Show Last 20 Lines

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

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

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

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

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

// RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- \ // RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: '[[clang::warn_unused_result]]'}]}" // RUN: -config="{CheckOptions: {modernize-use-nodiscard.ReplacementString: '[[clang::warn_unused_result]]'}}"
class Foo class Foo
{ {
public: public:
bool f1() const; bool f1() const;
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: function 'f1' should be marked {{\[\[clang::warn_unused_result\]\]}} [modernize-use-nodiscard] // 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; // CHECK-FIXES: {{\[\[clang::warn_unused_result\]\]}} bool f1() const;
Show All 14 Lines

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

// RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- \ // RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: '__attribute__((warn_unused_result))'}]}" // RUN: -config="{CheckOptions: {modernize-use-nodiscard.ReplacementString: '__attribute__((warn_unused_result))'}}"
class Foo class Foo
{ {
public: public:
bool f1() const; bool f1() const;
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: function 'f1' should be marked __attribute__((warn_unused_result)) [modernize-use-nodiscard] // 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; // CHECK-FIXES: __attribute__((warn_unused_result)) bool f1() const;
Show All 13 Lines

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

// RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- \ // RUN: %check_clang_tidy %s modernize-use-nodiscard %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: '[[gcc::warn_unused_result]]'}]}" // RUN: -config="{CheckOptions: {modernize-use-nodiscard.ReplacementString: '[[gcc::warn_unused_result]]'}}"
class Foo class Foo
{ {
public: public:
bool f1() const; bool f1() const;
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: function 'f1' should be marked {{\[\[gcc::warn_unused_result\]\]}} [modernize-use-nodiscard] // 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; // CHECK-FIXES: {{\[\[gcc::warn_unused_result\]\]}} bool f1() const;
Show All 14 Lines

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

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

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

// RUN: %check_clang_tidy -std=c++17-or-later %s modernize-use-nodiscard %t -- \ // RUN: %check_clang_tidy -std=c++17-or-later %s modernize-use-nodiscard %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-nodiscard.ReplacementString, value: 'NO_DISCARD'}]}" // RUN: -config="{CheckOptions: {modernize-use-nodiscard.ReplacementString: 'NO_DISCARD'}}"
namespace std { namespace std {
template <class> template <class>
class function; class function;
class string {}; class string {};
} }
namespace boost { namespace boost {
▲ Show 20 Lines • Show All 256 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy -std=c++11,c++14 %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: -config="{CheckOptions: {modernize-use-noexcept.ReplacementString: 'NOEXCEPT'}}" \
// RUN: -- -fexceptions // RUN: -- -fexceptions
// This test is not run in C++17 or later because dynamic exception // This test is not run in C++17 or later because dynamic exception
// specifications were removed in C++17. // specifications were removed in C++17.
// Example definition of NOEXCEPT -- simplified test to see if noexcept is supported. // Example definition of NOEXCEPT -- simplified test to see if noexcept is supported.
#if (__has_feature(cxx_noexcept)) #if (__has_feature(cxx_noexcept))
#define NOEXCEPT noexcept #define NOEXCEPT noexcept
#else #else
Show All 28 Lines

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

// RUN: %check_clang_tidy -std=c++11,c++14 %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: false}]}" \ // RUN: -config="{CheckOptions: {modernize-use-noexcept.UseNoexceptFalse: false}}" \
// RUN: -- -fexceptions // RUN: -- -fexceptions
// This test is not run in C++17 or later because dynamic exception // This test is not run in C++17 or later because dynamic exception
// specifications were removed in C++17. // specifications were removed in C++17.
using size_t = __SIZE_TYPE__; using size_t = __SIZE_TYPE__;
class A {}; class A {};
class B {}; class B {};
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s modernize-use-nullptr %t -- \ // RUN: %check_clang_tidy %s modernize-use-nullptr %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-nullptr.NullMacros, value: 'MY_NULL,NULL'}]}" // RUN: -config="{CheckOptions: {modernize-use-nullptr.NullMacros: 'MY_NULL,NULL'}}"
#define NULL 0 #define NULL 0
namespace std { namespace std {
typedef decltype(nullptr) nullptr_t; typedef decltype(nullptr) nullptr_t;
} // namespace std } // namespace std
▲ Show 20 Lines • Show All 294 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize/use-override-allow-override-and-final.cpp

// RUN: %check_clang_tidy %s modernize-use-override %t -- \ // RUN: %check_clang_tidy %s modernize-use-override %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-override.AllowOverrideAndFinal, value: true}]}" // RUN: -config="{CheckOptions: {modernize-use-override.AllowOverrideAndFinal: true}}"
struct Base { struct Base {
virtual ~Base(); virtual ~Base();
virtual void a(); virtual void a();
virtual void b(); virtual void b();
virtual void c(); virtual void c();
virtual void d(); virtual void d();
virtual void e(); virtual void e();
Show All 30 Lines

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

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

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

// RUN: %check_clang_tidy %s modernize-use-override %t -- \ // 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: -config="{CheckOptions: {modernize-use-override.OverrideSpelling: 'OVERRIDE',modernize-use-override.FinalSpelling: 'FINAL'}}"
#define ABSTRACT = 0 #define ABSTRACT = 0
#define OVERRIDE override #define OVERRIDE override
#define FINAL final #define FINAL final
#define VIRTUAL virtual #define VIRTUAL virtual
#define NOT_VIRTUAL #define NOT_VIRTUAL
#define NOT_OVERRIDE #define NOT_OVERRIDE
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s modernize-use-override %t -- \ // 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: -config="{CheckOptions: {modernize-use-override.OverrideSpelling: 'CUSTOM_OVERRIDE',modernize-use-override.FinalSpelling: 'CUSTOM_FINAL'}}"
// As if the macro was not defined. // As if the macro was not defined.
//#define CUSTOM_OVERRIDE override //#define CUSTOM_OVERRIDE override
//#define CUSTOM_FINAL override //#define CUSTOM_FINAL override
struct Base { struct Base {
virtual ~Base() {} virtual ~Base() {}
virtual void a(); virtual void a();
Show All 17 Lines

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

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

clang-tools-extra/test/clang-tidy/checkers/objc/forbidden-subclassing-custom.m

// RUN: %check_clang_tidy %s objc-forbidden-subclassing %t \ // RUN: %check_clang_tidy %s objc-forbidden-subclassing %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: objc-forbidden-subclassing.ClassNames, value: "Foo;Quux"}]}' \ // RUN: {objc-forbidden-subclassing.ClassNames: "Foo;Quux"}}' \
// RUN: -- // RUN: --
@interface UIImagePickerController @interface UIImagePickerController
@end @end
// Make sure custom config options replace (not add to) the default list. // Make sure custom config options replace (not add to) the default list.
@interface Waldo : UIImagePickerController @interface Waldo : UIImagePickerController
// CHECK-MESSAGES-NOT: :[[@LINE-1]]:12: warning: Objective-C interface 'Waldo' subclasses 'UIImagePickerController', which is not intended to be subclassed [objc-forbidden-subclassing] // CHECK-MESSAGES-NOT: :[[@LINE-1]]:12: warning: Objective-C interface 'Waldo' subclasses 'UIImagePickerController', which is not intended to be subclassed [objc-forbidden-subclassing]
Show All 28 Lines

clang-tools-extra/test/clang-tidy/checkers/openmp/exception-escape.cpp

// RUN: %check_clang_tidy %s openmp-exception-escape %t -- -extra-arg=-fopenmp=libomp -extra-arg=-fexceptions -config="{CheckOptions: [{key: openmp-exception-escape.IgnoredExceptions, value: 'ignored, ignored2'}]}" -- // RUN: %check_clang_tidy %s openmp-exception-escape %t -- -extra-arg=-fopenmp=libomp -extra-arg=-fexceptions -config="{CheckOptions: {openmp-exception-escape.IgnoredExceptions: 'ignored, ignored2'}}" --
int thrower() { int thrower() {
throw 42; throw 42;
} }
class ignored {}; class ignored {};
class ignored2 {}; class ignored2 {};
namespace std { namespace std {
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/performance/faster-string-find.cpp

// RUN: %check_clang_tidy %s performance-faster-string-find %t // RUN: %check_clang_tidy %s performance-faster-string-find %t
// RUN: %check_clang_tidy -check-suffix=CUSTOM %s performance-faster-string-find %t -- \ // RUN: %check_clang_tidy -check-suffix=CUSTOM %s performance-faster-string-find %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: performance-faster-string-find.StringLikeClasses, \ // RUN: {performance-faster-string-find.StringLikeClasses: \
// RUN: value: '::llvm::StringRef;'}]}" // RUN: '::llvm::StringRef;'}}"
namespace std { namespace std {
template <typename Char> template <typename Char>
struct basic_string { struct basic_string {
int find(const Char *, int = 0) const; int find(const Char *, int = 0) const;
int find(const Char *, int, int) const; int find(const Char *, int, int) const;
int rfind(const Char *) const; int rfind(const Char *) const;
int find_first_of(const Char *) const; int find_first_of(const Char *) const;
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s performance-for-range-copy %t -- \ // 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)?$;qualified::Type;::fully::QualifiedType'}]}" \ // RUN: -config="{CheckOptions: {performance-for-range-copy.AllowedTypes: '[Pp]ointer$;[Pp]tr$;[Rr]ef(erence)?$;qualified::Type;::fully::QualifiedType'}}" \
// RUN: -- -fno-delayed-template-parsing // RUN: -- -fno-delayed-template-parsing
template <typename T> template <typename T>
struct Iterator { struct Iterator {
void operator++() {} void operator++() {}
const T& operator*() { const T& operator*() {
static T* TT = new T(); static T* TT = new T();
return *TT; return *TT;
▲ Show 20 Lines • Show All 148 Lines • Show Last 20 Lines

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

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

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

// RUN: %check_clang_tidy %s performance-inefficient-vector-operation %t -- \ // RUN: %check_clang_tidy %s performance-inefficient-vector-operation %t -- \
// RUN: -format-style=llvm \ // RUN: -format-style=llvm \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: performance-inefficient-vector-operation.EnableProto, value: true}]}' // RUN: {performance-inefficient-vector-operation.EnableProto: true}}'
namespace std { namespace std {
typedef int size_t; typedef int size_t;
template<class E> class initializer_list { template<class E> class initializer_list {
public: public:
using value_type = E; using value_type = E;
▲ Show 20 Lines • Show All 377 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/performance/move-const-arg-const-ref.cpp

// RUN: %check_clang_tidy %s performance-move-const-arg %t \ // RUN: %check_clang_tidy %s performance-move-const-arg %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: performance-move-const-arg.CheckMoveToConstRef, value: false}]}' // RUN: {performance-move-const-arg.CheckMoveToConstRef: false}}'
namespace std { namespace std {
template <typename> template <typename>
struct remove_reference; struct remove_reference;
template <typename _Tp> template <typename _Tp>
struct remove_reference { struct remove_reference {
typedef _Tp type; typedef _Tp type;
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s performance-move-const-arg %t \ // RUN: %check_clang_tidy %s performance-move-const-arg %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: performance-move-const-arg.CheckTriviallyCopyableMove, value: false}]}' // RUN: {performance-move-const-arg.CheckTriviallyCopyableMove: false}}'
namespace std { namespace std {
template <typename> struct remove_reference; template <typename> struct remove_reference;
template <typename _Tp> struct remove_reference { typedef _Tp type; }; 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; };
template <typename _Tp> struct remove_reference<_Tp &&> { typedef _Tp type; }; template <typename _Tp> struct remove_reference<_Tp &&> { typedef _Tp type; };
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s performance-move-constructor-init,modernize-pass-by-value %t -- \ // RUN: %check_clang_tidy %s performance-move-constructor-init,modernize-pass-by-value %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: modernize-pass-by-value.ValuesOnly, value: true}]}' \ // RUN: {modernize-pass-by-value.ValuesOnly: true}}' \
// RUN: -- -isystem %clang_tidy_headers // RUN: -- -isystem %clang_tidy_headers
#include <s.h> #include <s.h>
// CHECK-FIXES: #include <utility> // CHECK-FIXES: #include <utility>
template <class T> struct remove_reference {typedef T type;}; 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;};
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/performance/unnecessary-copy-initialization-allowed-types.cpp

// RUN: %check_clang_tidy %s performance-unnecessary-copy-initialization %t -- -config="{CheckOptions: [{key: performance-unnecessary-copy-initialization.AllowedTypes, value: '[Pp]ointer$;[Pp]tr$;[Rr]ef(erence)?$'}]}" -- // RUN: %check_clang_tidy %s performance-unnecessary-copy-initialization %t -- -config="{CheckOptions: {performance-unnecessary-copy-initialization.AllowedTypes: '[Pp]ointer$;[Pp]tr$;[Rr]ef(erence)?$'}}" --
struct SmartPointer { struct SmartPointer {
~SmartPointer(); ~SmartPointer();
}; };
struct smart_pointer { struct smart_pointer {
~smart_pointer(); ~smart_pointer();
}; };
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/performance/unnecessary-copy-initialization-excluded-container-types.cpp

// RUN: %check_clang_tidy %s performance-unnecessary-copy-initialization %t -- -config="{CheckOptions: [{key: performance-unnecessary-copy-initialization.ExcludedContainerTypes, value: 'ns::ViewType$;::ConstInCorrectType$'}]}" -- // RUN: %check_clang_tidy %s performance-unnecessary-copy-initialization %t -- -config="{CheckOptions: {performance-unnecessary-copy-initialization.ExcludedContainerTypes: 'ns::ViewType$;::ConstInCorrectType$'}}" --
namespace ns { namespace ns {
template <typename T> template <typename T>
struct ViewType { struct ViewType {
ViewType(const T &); ViewType(const T &);
const T &view() const; const T &view() const;
}; };
} // namespace ns } // namespace ns
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/performance/unnecessary-value-param-allowed-types.cpp

// RUN: %check_clang_tidy %s performance-unnecessary-value-param %t -- -config="{CheckOptions: [{key: performance-unnecessary-value-param.AllowedTypes, value: '[Pp]ointer$;[Pp]tr$;[Rr]ef(erence)?$'}]}" -- // RUN: %check_clang_tidy %s performance-unnecessary-value-param %t -- -config="{CheckOptions: {performance-unnecessary-value-param.AllowedTypes: '[Pp]ointer$;[Pp]tr$;[Rr]ef(erence)?$'}}" --
struct SmartPointer { struct SmartPointer {
~SmartPointer(); ~SmartPointer();
}; };
struct smart_pointer { struct smart_pointer {
~smart_pointer(); ~smart_pointer();
}; };
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/portability/restrict-system-includes-allow.cpp

// RUN: %check_clang_tidy %s portability-restrict-system-includes %t \ // RUN: %check_clang_tidy %s portability-restrict-system-includes %t \
// RUN: -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: '*,-stddef.h'}]}" \ // RUN: -- -config="{CheckOptions: {portability-restrict-system-includes.Includes: '*,-stddef.h'}}" \
// RUN: -- -isystem %S/Inputs/restrict-system-includes/system // RUN: -- -isystem %S/Inputs/restrict-system-includes/system
// Test block-list functionality: allow all but stddef.h. // Test block-list functionality: allow all but stddef.h.
#include <stddef.h> #include <stddef.h>
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include stddef.h not allowed // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include stddef.h not allowed
#include <stdint.h> #include <stdint.h>
#include <float.h> #include <float.h>

clang-tools-extra/test/clang-tidy/checkers/portability/restrict-system-includes-disallow.cpp

// RUN: %check_clang_tidy %s portability-restrict-system-includes %t \ // RUN: %check_clang_tidy %s portability-restrict-system-includes %t \
// RUN: -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: '-*,stddef.h'}]}" \ // RUN: -- -config="{CheckOptions: {portability-restrict-system-includes.Includes: '-*,stddef.h'}}" \
// RUN: -- -isystem %S/Inputs/restrict-system-includes/system // RUN: -- -isystem %S/Inputs/restrict-system-includes/system
// Test allow-list functionality: disallow all but stddef.h. // Test allow-list functionality: disallow all but stddef.h.
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include stdint.h not allowed // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include stdint.h not allowed
#include <float.h> #include <float.h>
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include float.h not allowed // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include float.h not allowed

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

// RUN: %check_clang_tidy %s portability-restrict-system-includes %t \ // RUN: %check_clang_tidy %s portability-restrict-system-includes %t \
// RUN: -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: '-*,std*.h'}]}" \ // RUN: -- -config="{CheckOptions: {portability-restrict-system-includes.Includes: '-*,std*.h'}}" \
// RUN: -- -isystem %S/Inputs/restrict-system-includes/system // RUN: -- -isystem %S/Inputs/restrict-system-includes/system
// Test glob functionality: disallow all headers except those that match // Test glob functionality: disallow all headers except those that match
// pattern "std*.h". // pattern "std*.h".
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <float.h> #include <float.h>
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include float.h not allowed // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: system include float.h not allowed

clang-tools-extra/test/clang-tidy/checkers/portability/restrict-system-includes-transitive.cpp

// RUN: rm -rf %T/Headers // RUN: rm -rf %T/Headers
// RUN: mkdir %T/Headers // RUN: mkdir %T/Headers
// RUN: cp -r %S/Inputs/restrict-system-includes %T/Headers/portability-restrict-system-includes // RUN: cp -r %S/Inputs/restrict-system-includes %T/Headers/portability-restrict-system-includes
// RUN: %check_clang_tidy -std=c++11 %s portability-restrict-system-includes %t \ // RUN: %check_clang_tidy -std=c++11 %s portability-restrict-system-includes %t \
// RUN: -- -config="{CheckOptions: [{key: portability-restrict-system-includes.Includes, value: 'transitive.h,s.h'}]}" \ // RUN: -- -config="{CheckOptions: {portability-restrict-system-includes.Includes: 'transitive.h,s.h'}}" \
// RUN: -system-headers -header-filter=.* \ // RUN: -system-headers -header-filter=.* \
// RUN: -- -I %T/Headers/portability-restrict-system-includes -isystem %T/Headers/portability-restrict-system-includes/system // RUN: -- -I %T/Headers/portability-restrict-system-includes -isystem %T/Headers/portability-restrict-system-includes/system
// RUN: FileCheck -input-file=%T/Headers/portability-restrict-system-includes/transitive2.h %s -check-prefix=CHECK-FIXES // RUN: FileCheck -input-file=%T/Headers/portability-restrict-system-includes/transitive2.h %s -check-prefix=CHECK-FIXES
// RUN: rm -rf %T/Headers // RUN: rm -rf %T/Headers
// FIXME: Make the test work in all language modes. // FIXME: Make the test work in all language modes.
// transitive.h includes <r.h> and <t.h> // transitive.h includes <r.h> and <t.h>
#include <transitive.h> #include <transitive.h>
Show All 11 Lines

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

// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %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: -config='{CheckOptions: { \
// RUN: {key: portability-simd-intrinsics.Suggest, value: true} \ // RUN: portability-simd-intrinsics.Suggest: true \
// RUN: ]}' -- -target ppc64le -maltivec // RUN: }}' -- -target ppc64le -maltivec
// RUN: %check_clang_tidy -std=c++20-or-later %s portability-simd-intrinsics -check-suffix=CXX20 %t -- \ // RUN: %check_clang_tidy -std=c++20-or-later %s portability-simd-intrinsics -check-suffix=CXX20 %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: portability-simd-intrinsics.Suggest, value: true} \ // RUN: portability-simd-intrinsics.Suggest: true \
// RUN: ]}' -- -target ppc64le -maltivec // RUN: }}' -- -target ppc64le -maltivec
vector int vec_add(vector int, vector int); vector int vec_add(vector int, vector int);
void PPC() { void PPC() {
vector int i0, i1; vector int i0, i1;
vec_add(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] // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'vec_add' can be replaced by operator+ on std::experimental::simd objects [portability-simd-intrinsics]
// CHECK-MESSAGES-CXX20: :[[@LINE-2]]:3: warning: 'vec_add' can be replaced by operator+ on std::simd objects [portability-simd-intrinsics] // CHECK-MESSAGES-CXX20: :[[@LINE-2]]:3: warning: 'vec_add' can be replaced by operator+ on std::simd objects [portability-simd-intrinsics]
} }

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

// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %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: -config='{CheckOptions: { \
// RUN: {key: portability-simd-intrinsics.Suggest, value: true} \ // RUN: portability-simd-intrinsics.Suggest: true \
// RUN: ]}' -- -target x86_64 // RUN: }}' -- -target x86_64
// RUN: %check_clang_tidy -std=c++20-or-later %s portability-simd-intrinsics -check-suffix=CXX20 %t -- \ // RUN: %check_clang_tidy -std=c++20-or-later %s portability-simd-intrinsics -check-suffix=CXX20 %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: portability-simd-intrinsics.Suggest, value: true} \ // RUN: portability-simd-intrinsics.Suggest: true \
// RUN: ]}' -- -target x86_64 // RUN: }}' -- -target x86_64
typedef long long __m128i __attribute__((vector_size(16))); typedef long long __m128i __attribute__((vector_size(16)));
typedef double __m256 __attribute__((vector_size(32))); typedef double __m256 __attribute__((vector_size(32)));
__m128i _mm_add_epi32(__m128i, __m128i); __m128i _mm_add_epi32(__m128i, __m128i);
__m256 _mm256_load_pd(double const *); __m256 _mm256_load_pd(double const *);
void _mm256_store_pd(double *, __m256); void _mm256_store_pd(double *, __m256);
Show All 14 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/identifier-naming/global-style1/.clang-tidy

Checks: readability-identifier-naming Checks: readability-identifier-naming
CheckOptions: CheckOptions:
- key: readability-identifier-naming.GlobalFunctionCase readability-identifier-naming.GlobalFunctionCase: lower_case
value: lower_case readability-identifier-naming.IgnoreMainLikeFunctions: true
- key: readability-identifier-naming.IgnoreMainLikeFunctions
value: true

clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/identifier-naming/global-style2/.clang-tidy

Checks: readability-identifier-naming Checks: readability-identifier-naming
CheckOptions: CheckOptions:
- key: readability-identifier-naming.GlobalFunctionCase readability-identifier-naming.GlobalFunctionCase: UPPER_CASE
value: UPPER_CASE readability-identifier-naming.IgnoreMainLikeFunctions: false
- key: readability-identifier-naming.IgnoreMainLikeFunctions
value: false

clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/identifier-naming/hungarian-notation1/.clang-tidy

Checks: readability-identifier-naming Checks: readability-identifier-naming
CheckOptions: CheckOptions:
- key: readability-identifier-naming.AbstractClassCase readability-identifier-naming.AbstractClassCase: CamelCase
value: CamelCase readability-identifier-naming.ClassCase: CamelCase
- key: readability-identifier-naming.ClassCase readability-identifier-naming.ClassConstantCase: CamelCase
value: CamelCase readability-identifier-naming.ClassMemberCase: CamelCase
- key: readability-identifier-naming.ClassConstantCase readability-identifier-naming.ConstantCase: CamelCase
value: CamelCase readability-identifier-naming.ConstantMemberCase: CamelCase
- key: readability-identifier-naming.ClassMemberCase readability-identifier-naming.ConstantParameterCase: CamelCase
value: CamelCase readability-identifier-naming.ConstantPointerParameterCase: CamelCase
- key: readability-identifier-naming.ConstantCase readability-identifier-naming.ConstexprVariableCase: CamelCase
value: CamelCase readability-identifier-naming.EnumConstantCase: CamelCase
- key: readability-identifier-naming.ConstantMemberCase readability-identifier-naming.GlobalConstantCase: CamelCase
value: CamelCase readability-identifier-naming.GlobalConstantPointerCase: CamelCase
- key: readability-identifier-naming.ConstantParameterCase readability-identifier-naming.GlobalPointerCase: CamelCase
value: CamelCase readability-identifier-naming.GlobalVariableCase: CamelCase
- key: readability-identifier-naming.ConstantPointerParameterCase readability-identifier-naming.LocalConstantCase: CamelCase
value: CamelCase readability-identifier-naming.LocalConstantPointerCase: CamelCase
- key: readability-identifier-naming.ConstexprVariableCase readability-identifier-naming.LocalPointerCase: CamelCase
value: CamelCase readability-identifier-naming.LocalVariableCase: CamelCase
- key: readability-identifier-naming.EnumConstantCase readability-identifier-naming.MemberCase: CamelCase
value: CamelCase readability-identifier-naming.ParameterCase: CamelCase
- key: readability-identifier-naming.GlobalConstantCase readability-identifier-naming.PointerParameterCase: CamelCase
value: CamelCase readability-identifier-naming.PrivateMemberCase: CamelCase
- key: readability-identifier-naming.GlobalConstantPointerCase readability-identifier-naming.ProtectedMemberCase: CamelCase
value: CamelCase readability-identifier-naming.PublicMemberCase: CamelCase
- key: readability-identifier-naming.GlobalPointerCase readability-identifier-naming.ScopedEnumConstantCase: CamelCase
value: CamelCase readability-identifier-naming.StaticConstantCase: CamelCase
- key: readability-identifier-naming.GlobalVariableCase readability-identifier-naming.StaticVariableCase: CamelCase
value: CamelCase readability-identifier-naming.VariableCase: CamelCase
- key: readability-identifier-naming.LocalConstantCase readability-identifier-naming.AbstractClassHungarianPrefix: On
value: CamelCase readability-identifier-naming.ClassHungarianPrefix: On
- key: readability-identifier-naming.LocalConstantPointerCase readability-identifier-naming.ClassConstantHungarianPrefix: On
value: CamelCase readability-identifier-naming.ClassMemberHungarianPrefix: On
- key: readability-identifier-naming.LocalPointerCase readability-identifier-naming.ConstantHungarianPrefix: On
value: CamelCase readability-identifier-naming.ConstantMemberHungarianPrefix: On
- key: readability-identifier-naming.LocalVariableCase readability-identifier-naming.ConstantParameterHungarianPrefix: On
value: CamelCase readability-identifier-naming.ConstantPointerParameterHungarianPrefix: On
- key: readability-identifier-naming.MemberCase readability-identifier-naming.ConstexprVariableHungarianPrefix: On
value: CamelCase readability-identifier-naming.EnumConstantHungarianPrefix: On
- key: readability-identifier-naming.ParameterCase readability-identifier-naming.GlobalConstantHungarianPrefix: On
value: CamelCase readability-identifier-naming.GlobalConstantPointerHungarianPrefix: On
- key: readability-identifier-naming.PointerParameterCase readability-identifier-naming.GlobalPointerHungarianPrefix: On
value: CamelCase readability-identifier-naming.GlobalVariableHungarianPrefix: On
- key: readability-identifier-naming.PrivateMemberCase readability-identifier-naming.LocalConstantHungarianPrefix: On
value: CamelCase readability-identifier-naming.LocalConstantPointerHungarianPrefix: On
- key: readability-identifier-naming.ProtectedMemberCase readability-identifier-naming.LocalPointerHungarianPrefix: On
value: CamelCase readability-identifier-naming.LocalVariableHungarianPrefix: On
- key: readability-identifier-naming.PublicMemberCase readability-identifier-naming.MemberHungarianPrefix: On
value: CamelCase readability-identifier-naming.ParameterHungarianPrefix: On
- key: readability-identifier-naming.ScopedEnumConstantCase readability-identifier-naming.PointerParameterHungarianPrefix: On
value: CamelCase readability-identifier-naming.PrivateMemberHungarianPrefix: On
- key: readability-identifier-naming.StaticConstantCase readability-identifier-naming.ProtectedMemberHungarianPrefix: On
value: CamelCase readability-identifier-naming.PublicMemberHungarianPrefix: On
- key: readability-identifier-naming.StaticVariableCase readability-identifier-naming.ScopedEnumConstantHungarianPrefix: On
value: CamelCase readability-identifier-naming.StaticConstantHungarianPrefix: On
- key: readability-identifier-naming.VariableCase readability-identifier-naming.StaticVariableHungarianPrefix: On
value: CamelCase readability-identifier-naming.VariableHungarianPrefix: On
- key: readability-identifier-naming.AbstractClassHungarianPrefix
value: On
- key: readability-identifier-naming.ClassHungarianPrefix
value: On
- key: readability-identifier-naming.ClassConstantHungarianPrefix
value: On
- key: readability-identifier-naming.ClassMemberHungarianPrefix
value: On
- key: readability-identifier-naming.ConstantHungarianPrefix
value: On
- key: readability-identifier-naming.ConstantMemberHungarianPrefix
value: On
- key: readability-identifier-naming.ConstantParameterHungarianPrefix
value: On
- key: readability-identifier-naming.ConstantPointerParameterHungarianPrefix
value: On
- key: readability-identifier-naming.ConstexprVariableHungarianPrefix
value: On
- key: readability-identifier-naming.EnumConstantHungarianPrefix
value: On
- key: readability-identifier-naming.GlobalConstantHungarianPrefix
value: On
- key: readability-identifier-naming.GlobalConstantPointerHungarianPrefix
value: On
- key: readability-identifier-naming.GlobalPointerHungarianPrefix
value: On
- key: readability-identifier-naming.GlobalVariableHungarianPrefix
value: On
- key: readability-identifier-naming.LocalConstantHungarianPrefix
value: On
- key: readability-identifier-naming.LocalConstantPointerHungarianPrefix
value: On
- key: readability-identifier-naming.LocalPointerHungarianPrefix
value: On
- key: readability-identifier-naming.LocalVariableHungarianPrefix
value: On
- key: readability-identifier-naming.MemberHungarianPrefix
value: On
- key: readability-identifier-naming.ParameterHungarianPrefix
value: On
- key: readability-identifier-naming.PointerParameterHungarianPrefix
value: On
- key: readability-identifier-naming.PrivateMemberHungarianPrefix
value: On
- key: readability-identifier-naming.ProtectedMemberHungarianPrefix
value: On
- key: readability-identifier-naming.PublicMemberHungarianPrefix
value: On
- key: readability-identifier-naming.ScopedEnumConstantHungarianPrefix
value: On
- key: readability-identifier-naming.StaticConstantHungarianPrefix
value: On
- key: readability-identifier-naming.StaticVariableHungarianPrefix
value: On
- key: readability-identifier-naming.VariableHungarianPrefix
value: On

clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/identifier-naming/hungarian-notation2/.clang-tidy

Checks: readability-identifier-naming Checks: readability-identifier-naming
CheckOptions: CheckOptions:
- key: readability-identifier-naming.AbstractClassCase readability-identifier-naming.AbstractClassCase: CamelCase
value: CamelCase readability-identifier-naming.ClassCase: CamelCase
- key: readability-identifier-naming.ClassCase readability-identifier-naming.ClassConstantCase: CamelCase
value: CamelCase readability-identifier-naming.ClassMemberCase: CamelCase
- key: readability-identifier-naming.ClassConstantCase readability-identifier-naming.ConstantCase: CamelCase
value: CamelCase readability-identifier-naming.ConstantMemberCase: CamelCase
- key: readability-identifier-naming.ClassMemberCase readability-identifier-naming.ConstantParameterCase: CamelCase
value: CamelCase readability-identifier-naming.ConstantPointerParameterCase: CamelCase
- key: readability-identifier-naming.ConstantCase readability-identifier-naming.ConstexprVariableCase: CamelCase
value: CamelCase readability-identifier-naming.EnumConstantCase: CamelCase
- key: readability-identifier-naming.ConstantMemberCase readability-identifier-naming.GlobalConstantCase: CamelCase
value: CamelCase readability-identifier-naming.GlobalConstantPointerCase: CamelCase
- key: readability-identifier-naming.ConstantParameterCase readability-identifier-naming.GlobalPointerCase: CamelCase
value: CamelCase readability-identifier-naming.GlobalVariableCase: CamelCase
- key: readability-identifier-naming.ConstantPointerParameterCase readability-identifier-naming.LocalConstantCase: CamelCase
value: CamelCase readability-identifier-naming.LocalConstantPointerCase: CamelCase
- key: readability-identifier-naming.ConstexprVariableCase readability-identifier-naming.LocalPointerCase: CamelCase
value: CamelCase readability-identifier-naming.LocalVariableCase: CamelCase
- key: readability-identifier-naming.EnumConstantCase readability-identifier-naming.MemberCase: CamelCase
value: CamelCase readability-identifier-naming.ParameterCase: CamelCase
- key: readability-identifier-naming.GlobalConstantCase readability-identifier-naming.PointerParameterCase: CamelCase
value: CamelCase readability-identifier-naming.PrivateMemberCase: CamelCase
- key: readability-identifier-naming.GlobalConstantPointerCase readability-identifier-naming.ProtectedMemberCase: CamelCase
value: CamelCase readability-identifier-naming.PublicMemberCase: CamelCase
- key: readability-identifier-naming.GlobalPointerCase readability-identifier-naming.ScopedEnumConstantCase: CamelCase
value: CamelCase readability-identifier-naming.StaticConstantCase: CamelCase
- key: readability-identifier-naming.GlobalVariableCase readability-identifier-naming.StaticVariableCase: CamelCase
value: CamelCase readability-identifier-naming.VariableCase: CamelCase
- key: readability-identifier-naming.LocalConstantCase readability-identifier-naming.AbstractClassHungarianPrefix: On
value: CamelCase readability-identifier-naming.ClassHungarianPrefix: On
- key: readability-identifier-naming.LocalConstantPointerCase readability-identifier-naming.ClassConstantHungarianPrefix: On
value: CamelCase readability-identifier-naming.ClassMemberHungarianPrefix: On
- key: readability-identifier-naming.LocalPointerCase readability-identifier-naming.ConstantHungarianPrefix: On
value: CamelCase readability-identifier-naming.ConstantMemberHungarianPrefix: On
- key: readability-identifier-naming.LocalVariableCase readability-identifier-naming.ConstantParameterHungarianPrefix: On
value: CamelCase readability-identifier-naming.ConstantPointerParameterHungarianPrefix: On
- key: readability-identifier-naming.MemberCase readability-identifier-naming.ConstexprVariableHungarianPrefix: On
value: CamelCase readability-identifier-naming.EnumConstantHungarianPrefix: On
- key: readability-identifier-naming.ParameterCase readability-identifier-naming.GlobalConstantHungarianPrefix: On
value: CamelCase readability-identifier-naming.GlobalConstantPointerHungarianPrefix: On
- key: readability-identifier-naming.PointerParameterCase readability-identifier-naming.GlobalPointerHungarianPrefix: On
value: CamelCase readability-identifier-naming.GlobalVariableHungarianPrefix: On
- key: readability-identifier-naming.PrivateMemberCase readability-identifier-naming.LocalConstantHungarianPrefix: On
value: CamelCase readability-identifier-naming.LocalConstantPointerHungarianPrefix: On
- key: readability-identifier-naming.ProtectedMemberCase readability-identifier-naming.LocalPointerHungarianPrefix: On
value: CamelCase readability-identifier-naming.LocalVariableHungarianPrefix: On
- key: readability-identifier-naming.PublicMemberCase readability-identifier-naming.MemberHungarianPrefix: On
value: CamelCase readability-identifier-naming.ParameterHungarianPrefix: On
- key: readability-identifier-naming.ScopedEnumConstantCase readability-identifier-naming.PointerParameterHungarianPrefix: On
value: CamelCase readability-identifier-naming.PrivateMemberHungarianPrefix: On
- key: readability-identifier-naming.StaticConstantCase readability-identifier-naming.ProtectedMemberHungarianPrefix: On
value: CamelCase readability-identifier-naming.PublicMemberHungarianPrefix: On
- key: readability-identifier-naming.StaticVariableCase readability-identifier-naming.ScopedEnumConstantHungarianPrefix: On
value: CamelCase readability-identifier-naming.StaticConstantHungarianPrefix: On
- key: readability-identifier-naming.VariableCase readability-identifier-naming.StaticVariableHungarianPrefix: On
value: CamelCase readability-identifier-naming.VariableHungarianPrefix: On
- key: readability-identifier-naming.AbstractClassHungarianPrefix readability-identifier-naming.HungarianNotation.Options.TreatStructAsClass: false
value: On readability-identifier-naming.HungarianNotation.DerivedType.Array: ary
- key: readability-identifier-naming.ClassHungarianPrefix readability-identifier-naming.HungarianNotation.DerivedType.Pointer: p
value: On readability-identifier-naming.HungarianNotation.DerivedType.FunctionPointer: fn
- key: readability-identifier-naming.ClassConstantHungarianPrefix readability-identifier-naming.HungarianNotation.CString.CharPrinter: sz
value: On readability-identifier-naming.HungarianNotation.CString.CharArray: sz
- key: readability-identifier-naming.ClassMemberHungarianPrefix readability-identifier-naming.HungarianNotation.CString.WideCharPrinter: wsz
value: On readability-identifier-naming.HungarianNotation.CString.WideCharArray: wsz
- key: readability-identifier-naming.ConstantHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.int8_t: i8
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.int16_t: i16
- key: readability-identifier-naming.ConstantMemberHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.int32_t: i32
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.int64_t: i64
- key: readability-identifier-naming.ConstantParameterHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.uint8_t: u8
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.uint16_t: u16
- key: readability-identifier-naming.ConstantPointerParameterHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.uint32_t: u32
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.uint64_t: u64
- key: readability-identifier-naming.ConstexprVariableHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.char8_t: c8
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.char16_t: c16
- key: readability-identifier-naming.EnumConstantHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.char32_t: c32
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.float: f
- key: readability-identifier-naming.GlobalConstantHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.double: d
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.char: c
- key: readability-identifier-naming.GlobalConstantPointerHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.bool: b
value: On readability-identifier-naming.HungarianNotation.PrimitiveType._Bool: b
- key: readability-identifier-naming.GlobalPointerHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.int: i
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.size_t: n
- key: readability-identifier-naming.GlobalVariableHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.wchar_t: wc
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.short-int: si
- key: readability-identifier-naming.LocalConstantHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.short: s
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.signed-int: si
- key: readability-identifier-naming.LocalConstantPointerHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.signed-short: ss
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.signed-short-int: ssi
- key: readability-identifier-naming.LocalPointerHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-long-int: slli
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-long: sll
- key: readability-identifier-naming.LocalVariableHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-int: sli
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long: sl
- key: readability-identifier-naming.MemberHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.signed: s
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-long-int: ulli
- key: readability-identifier-naming.ParameterHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-long: ull
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-int: uli
- key: readability-identifier-naming.PointerParameterHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long: ul
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-short-int: usi
- key: readability-identifier-naming.PrivateMemberHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-short: us
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-int: ui
- key: readability-identifier-naming.ProtectedMemberHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned: u
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.long-long-int: lli
- key: readability-identifier-naming.PublicMemberHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.long-double: ld
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.long-long: ll
- key: readability-identifier-naming.ScopedEnumConstantHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.long-int: li
value: On readability-identifier-naming.HungarianNotation.PrimitiveType.long: l
- key: readability-identifier-naming.StaticConstantHungarianPrefix readability-identifier-naming.HungarianNotation.PrimitiveType.ptrdiff_t: p
value: On readability-identifier-naming.HungarianNotation.UserDefinedType.BOOL: b
- key: readability-identifier-naming.StaticVariableHungarianPrefix readability-identifier-naming.HungarianNotation.UserDefinedType.BOOLEAN: b
value: On readability-identifier-naming.HungarianNotation.UserDefinedType.BYTE: by
- key: readability-identifier-naming.VariableHungarianPrefix readability-identifier-naming.HungarianNotation.UserDefinedType.CHAR: c
value: On readability-identifier-naming.HungarianNotation.UserDefinedType.UCHAR: uc
- key: readability-identifier-naming.HungarianNotation.Options.TreatStructAsClass readability-identifier-naming.HungarianNotation.UserDefinedType.SHORT: s
value: false readability-identifier-naming.HungarianNotation.UserDefinedType.USHORT: us
- key: readability-identifier-naming.HungarianNotation.DerivedType.Array readability-identifier-naming.HungarianNotation.UserDefinedType.WORD: w
value: ary readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD: dw
- key: readability-identifier-naming.HungarianNotation.DerivedType.Pointer readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD32: dw32
value: p readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD64: dw64
- key: readability-identifier-naming.HungarianNotation.DerivedType.FunctionPointer readability-identifier-naming.HungarianNotation.UserDefinedType.LONG: l
value: fn readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG: ul
- key: readability-identifier-naming.HungarianNotation.CString.CharPrinter readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG32: ul32
value: sz readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG64: ul64
- key: readability-identifier-naming.HungarianNotation.CString.CharArray readability-identifier-naming.HungarianNotation.UserDefinedType.ULONGLONG: ull
value: sz readability-identifier-naming.HungarianNotation.UserDefinedType.HANDLE: h
- key: readability-identifier-naming.HungarianNotation.CString.WideCharPrinter readability-identifier-naming.HungarianNotation.UserDefinedType.INT: i
value: wsz readability-identifier-naming.HungarianNotation.UserDefinedType.INT8: i8
- key: readability-identifier-naming.HungarianNotation.CString.WideCharArray readability-identifier-naming.HungarianNotation.UserDefinedType.INT16: i16
value: wsz readability-identifier-naming.HungarianNotation.UserDefinedType.INT32: i32
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.int8_t readability-identifier-naming.HungarianNotation.UserDefinedType.INT64: i64
value: i8 readability-identifier-naming.HungarianNotation.UserDefinedType.UINT: ui
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.int16_t readability-identifier-naming.HungarianNotation.UserDefinedType.UINT8: u8
value: i16 readability-identifier-naming.HungarianNotation.UserDefinedType.UINT16: u16
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.int32_t readability-identifier-naming.HungarianNotation.UserDefinedType.UINT32: u32
value: i32 readability-identifier-naming.HungarianNotation.UserDefinedType.UINT64: u64
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.int64_t readability-identifier-naming.HungarianNotation.UserDefinedType.PVOID: p
value: i64
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint8_t
value: u8
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint16_t
value: u16
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint32_t
value: u32
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint64_t
value: u64
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.char8_t
value: c8
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.char16_t
value: c16
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.char32_t
value: c32
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.float
value: f
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.double
value: d
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.char
value: c
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.bool
value: b
- key: readability-identifier-naming.HungarianNotation.PrimitiveType._Bool
value: b
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.int
value: i
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.size_t
value: n
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.wchar_t
value: wc
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.short-int
value: si
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.short
value: s
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-int
value: si
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-short
value: ss
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-short-int
value: ssi
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-long-int
value: slli
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-long
value: sll
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-int
value: sli
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long
value: sl
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed
value: s
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-long-int
value: ulli
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-long
value: ull
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-int
value: uli
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long
value: ul
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-short-int
value: usi
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-short
value: us
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-int
value: ui
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned
value: u
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-long-int
value: lli
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-double
value: ld
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-long
value: ll
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-int
value: li
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.long
value: l
- key: readability-identifier-naming.HungarianNotation.PrimitiveType.ptrdiff_t
value: p
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.BOOL
value: b
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.BOOLEAN
value: b
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.BYTE
value: by
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.CHAR
value: c
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.UCHAR
value: uc
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.SHORT
value: s
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.USHORT
value: us
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.WORD
value: w
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD
value: dw
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD32
value: dw32
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD64
value: dw64
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.LONG
value: l
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG
value: ul
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG32
value: ul32
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG64
value: ul64
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONGLONG
value: ull
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.HANDLE
value: h
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT
value: i
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT8
value: i8
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT16
value: i16
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT32
value: i32
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT64
value: i64
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT
value: ui
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT8
value: u8
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT16
value: u16
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT32
value: u32
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT64
value: u64
- key: readability-identifier-naming.HungarianNotation.UserDefinedType.PVOID
value: p

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

// RUN: %check_clang_tidy %s readability-braces-around-statements %t -- -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 4}]}" -- // RUN: %check_clang_tidy %s readability-braces-around-statements %t -- -config="{CheckOptions: {readability-braces-around-statements.ShortStatementLines: 4}}" --
void do_something(const char *) {} void do_something(const char *) {}
bool cond(const char *) { bool cond(const char *) {
return false; return false;
} }
void test() { void test() {
Show All 21 Lines

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

// RUN: %check_clang_tidy %s readability-braces-around-statements %t -- -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 1}]}" -- // RUN: %check_clang_tidy %s readability-braces-around-statements %t -- -config="{CheckOptions: {readability-braces-around-statements.ShortStatementLines: 1}}" --
void do_something(const char *) {} void do_something(const char *) {}
bool cond(const char *) { bool cond(const char *) {
return false; return false;
} }
void test() { void test() {
Show All 27 Lines

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

// RUN: %check_clang_tidy %s readability-braces-around-statements %t -- -config="{CheckOptions: [{key: readability-braces-around-statements.ShortStatementLines, value: 2}]}" -- // RUN: %check_clang_tidy %s readability-braces-around-statements %t -- -config="{CheckOptions: {readability-braces-around-statements.ShortStatementLines: 2}}" --
void do_something(const char *) {} void do_something(const char *) {}
bool cond(const char *) { bool cond(const char *) {
return false; return false;
} }
void test() { void test() {
Show All 24 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/else-after-return-no-cond-var-refactor.cpp

// RUN: %check_clang_tidy %s readability-else-after-return %t -- \ // RUN: %check_clang_tidy %s readability-else-after-return %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: readability-else-after-return.WarnOnConditionVariables, value: false}, \ // RUN: readability-else-after-return.WarnOnConditionVariables: false, \
// RUN: ]}' // RUN: }}'
bool foo(int Y) { bool foo(int Y) {
// Excess scopes are here so that the check would have to opportunity to // Excess scopes are here so that the check would have to opportunity to
// refactor the variable out of the condition. // refactor the variable out of the condition.
// Expect warnings here as we don't need to move declaration of 'X' out of the // Expect warnings here as we don't need to move declaration of 'X' out of the
// if condition as its not used in the else. // if condition as its not used in the else.
{ {
Show All 30 Lines

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

// RUN: %check_clang_tidy %s readability-else-after-return %t -- \ // RUN: %check_clang_tidy %s readability-else-after-return %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: readability-else-after-return.WarnOnUnfixable, value: false}, \ // RUN: readability-else-after-return.WarnOnUnfixable: false, \
// RUN: ]}' // RUN: }}'
int h(int); int h(int);
int lifeTimeExtensionTests(int a) { int lifeTimeExtensionTests(int a) {
if (a > 0) { if (a > 0) {
return a; return a;
} else { } else {
// CHECK-MESSAGES-NOT: :[[@LINE-1]]:5: warning: do not use 'else' after 'return' // CHECK-MESSAGES-NOT: :[[@LINE-1]]:5: warning: do not use 'else' after 'return'
Show All 19 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/function-cognitive-complexity-flags.cpp

// RUN: %check_clang_tidy %s readability-function-cognitive-complexity %t -- \ // RUN: %check_clang_tidy %s readability-function-cognitive-complexity %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-function-cognitive-complexity.Threshold, \ // RUN: {readability-function-cognitive-complexity.Threshold: 0, \
// RUN: value: 0}, \ // RUN: readability-function-cognitive-complexity.DescribeBasicIncrements: "false"}}'
// RUN: {key: readability-function-cognitive-complexity.DescribeBasicIncrements, \
// RUN: value: "false"} ]}'
// RUN: %check_clang_tidy -check-suffix=THRESHOLD5 %s readability-function-cognitive-complexity %t -- \ // RUN: %check_clang_tidy -check-suffix=THRESHOLD5 %s readability-function-cognitive-complexity %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-function-cognitive-complexity.Threshold, \ // RUN: {readability-function-cognitive-complexity.Threshold: 5, \
// RUN: value: 5}, \ // RUN: readability-function-cognitive-complexity.DescribeBasicIncrements: "false"}}'
// RUN: {key: readability-function-cognitive-complexity.DescribeBasicIncrements, \
// RUN: value: "false"} ]}'
// RUN: %check_clang_tidy -check-suffix=IGNORE-MACROS %s readability-function-cognitive-complexity %t -- \ // RUN: %check_clang_tidy -check-suffix=IGNORE-MACROS %s readability-function-cognitive-complexity %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-function-cognitive-complexity.Threshold, \ // RUN: {readability-function-cognitive-complexity.Threshold: 0, \
// RUN: value: 0}, \ // RUN: readability-function-cognitive-complexity.IgnoreMacros: "true", \
// RUN: {key: readability-function-cognitive-complexity.IgnoreMacros, \ // RUN: readability-function-cognitive-complexity.DescribeBasicIncrements: "false"}}'
// RUN: value: "true"}, \
// RUN: {key: readability-function-cognitive-complexity.DescribeBasicIncrements, \
// RUN: value: "false"} ]}'
// RUN: %check_clang_tidy -check-suffix=GLOBAL-IGNORE-MACROS %s readability-function-cognitive-complexity %t -- \ // RUN: %check_clang_tidy -check-suffix=GLOBAL-IGNORE-MACROS %s readability-function-cognitive-complexity %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-function-cognitive-complexity.Threshold, \ // RUN: {readability-function-cognitive-complexity.Threshold: 0, \
// RUN: value: 0}, \ // RUN: IgnoreMacros: "true", \
// RUN: {key: IgnoreMacros, \ // RUN: readability-function-cognitive-complexity.DescribeBasicIncrements: "false"}}'
// RUN: value: "true"}, \
// RUN: {key: readability-function-cognitive-complexity.DescribeBasicIncrements, \
// RUN: value: "false"} ]}'
void func_of_complexity_4() { void func_of_complexity_4() {
// CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'func_of_complexity_4' has cognitive complexity of 4 (threshold 0) [readability-function-cognitive-complexity] // CHECK-NOTES: :[[@LINE-1]]:6: warning: function 'func_of_complexity_4' has cognitive complexity of 4 (threshold 0) [readability-function-cognitive-complexity]
// CHECK-NOTES-IGNORE-MACROS: :[[@LINE-2]]:6: warning: function 'func_of_complexity_4' has cognitive complexity of 4 (threshold 0) [readability-function-cognitive-complexity] // CHECK-NOTES-IGNORE-MACROS: :[[@LINE-2]]:6: warning: function 'func_of_complexity_4' has cognitive complexity of 4 (threshold 0) [readability-function-cognitive-complexity]
// CHECK-NOTES-GLOBAL-IGNORE-MACROS: :[[@LINE-3]]:6: warning: function 'func_of_complexity_4' has cognitive complexity of 4 (threshold 0) [readability-function-cognitive-complexity] // CHECK-NOTES-GLOBAL-IGNORE-MACROS: :[[@LINE-3]]:6: warning: function 'func_of_complexity_4' has cognitive complexity of 4 (threshold 0) [readability-function-cognitive-complexity]
if (1) { if (1) {
if (1) { if (1) {
} }
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/function-cognitive-complexity.cpp

// RUN: %check_clang_tidy %s readability-function-cognitive-complexity %t -- -config='{CheckOptions: [{key: readability-function-cognitive-complexity.Threshold, value: 0}]}' -- -std=c++11 -fblocks -fexceptions -w // RUN: %check_clang_tidy %s readability-function-cognitive-complexity %t -- -config='{CheckOptions: {readability-function-cognitive-complexity.Threshold: 0}}' -- -std=c++11 -fblocks -fexceptions -w
// any function should be checked. // any function should be checked.
extern int ext_func(int x = 0); extern int ext_func(int x = 0);
int some_func(int x = 0); int some_func(int x = 0);
static int some_other_func(int x = 0) {} static int some_other_func(int x = 0) {}
▲ Show 20 Lines • Show All 1,008 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/function-size-variables-c++17.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++17 // RUN: %check_clang_tidy %s readability-function-size %t -- -config='{CheckOptions: {readability-function-size.LineThreshold: 0, readability-function-size.StatementThreshold: 0, readability-function-size.BranchThreshold: 0, readability-function-size.ParameterThreshold: 5, readability-function-size.NestingThreshold: 2, readability-function-size.VariableThreshold: 1}}' -- -std=c++17
void structured_bindings() { void structured_bindings() {
int a[2] = {1, 2}; int a[2] = {1, 2};
auto [x, y] = a; auto [x, y] = a;
} }
// CHECK-MESSAGES: :[[@LINE-4]]:6: warning: function 'structured_bindings' exceeds recommended size/complexity thresholds [readability-function-size] // CHECK-MESSAGES: :[[@LINE-4]]:6: warning: function 'structured_bindings' exceeds recommended size/complexity thresholds [readability-function-size]
// CHECK-MESSAGES: :[[@LINE-5]]:6: note: 3 lines including whitespace and comments (threshold 0) // CHECK-MESSAGES: :[[@LINE-5]]:6: note: 3 lines including whitespace and comments (threshold 0)
// CHECK-MESSAGES: :[[@LINE-6]]:6: note: 2 statements (threshold 0) // CHECK-MESSAGES: :[[@LINE-6]]:6: note: 2 statements (threshold 0)
Show All 12 Lines

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

// RUN: %check_clang_tidy %s readability-function-size %t -- \ // RUN: %check_clang_tidy %s readability-function-size %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: readability-function-size.LineThreshold, value: 0}, \ // RUN: readability-function-size.LineThreshold: 0, \
// RUN: {key: readability-function-size.StatementThreshold, value: 0}, \ // RUN: readability-function-size.StatementThreshold: 0, \
// RUN: {key: readability-function-size.BranchThreshold, value: 0}, \ // RUN: readability-function-size.BranchThreshold: 0, \
// RUN: {key: readability-function-size.ParameterThreshold, value: 5}, \ // RUN: readability-function-size.ParameterThreshold: 5, \
// RUN: {key: readability-function-size.NestingThreshold, value: 2}, \ // RUN: readability-function-size.NestingThreshold: 2, \
// RUN: {key: readability-function-size.VariableThreshold, value: 1} \ // RUN: readability-function-size.VariableThreshold: 1 \
// RUN: ]}' // RUN: }}'
// Bad formatting is intentional, don't run clang-format over the whole file! // Bad formatting is intentional, don't run clang-format over the whole file!
void foo1() { void foo1() {
} }
void foo2() {;} void foo2() {;}
// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'foo2' exceeds recommended size/complexity thresholds [readability-function-size] // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'foo2' exceeds recommended size/complexity thresholds [readability-function-size]
▲ Show 20 Lines • Show All 292 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/identifier-length.cpp

// RUN: %check_clang_tidy %s readability-identifier-length %t \ // RUN: %check_clang_tidy %s readability-identifier-length %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-identifier-length.IgnoredVariableNames, value: "^[xy]$"}]}' \ // RUN: {readability-identifier-length.IgnoredVariableNames: "^[xy]$"}}' \
// RUN: -- -fexceptions // RUN: -- -fexceptions
struct myexcept { struct myexcept {
int val; int val;
}; };
struct simpleexcept { struct simpleexcept {
int other; int other;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-bugfix-name-conflicts.cpp

// RUN: %check_clang_tidy %s readability-identifier-naming %t -- \ // RUN: %check_clang_tidy %s readability-identifier-naming %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: readability-identifier-naming.ParameterCase, value: lower_case} \ // RUN: readability-identifier-naming.ParameterCase: lower_case \
// RUN: ]}' // RUN: }}'
int func(int Break) { int func(int Break) {
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for parameter 'Break'; cannot be fixed because 'break' would conflict with a keyword // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for parameter 'Break'; cannot be fixed because 'break' would conflict with a keyword
// CHECK-FIXES: {{^}}int func(int Break) {{{$}} // CHECK-FIXES: {{^}}int func(int Break) {{{$}}
if (Break == 1) { if (Break == 1) {
// CHECK-FIXES: {{^}} if (Break == 1) {{{$}} // CHECK-FIXES: {{^}} if (Break == 1) {{{$}}
return 2; return 2;
} }
Show All 25 Lines

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

// RUN: clang-tidy %s -checks=readability-identifier-naming \ // RUN: clang-tidy %s -checks=readability-identifier-naming \
// RUN: -config="{CheckOptions: [\ // RUN: -config="{CheckOptions: {\
// RUN: {key: readability-identifier-naming.FunctionCase, value: camelback}, \ // RUN: readability-identifier-naming.FunctionCase: camelback, \
// RUN: {key: readability-identifier-naming.VariableCase, value: camelBack}, \ // RUN: readability-identifier-naming.VariableCase: camelBack, \
// RUN: {key: readability-identifier-naming.ClassCase, value: UUPER_CASE}, \ // RUN: readability-identifier-naming.ClassCase: UUPER_CASE, \
// RUN: {key: readability-identifier-naming.StructCase, value: CAMEL}, \ // RUN: readability-identifier-naming.StructCase: CAMEL, \
// RUN: {key: readability-identifier-naming.EnumCase, value: AnY_cASe}, \ // RUN: readability-identifier-naming.EnumCase: AnY_cASe, \
// RUN: ]}" 2>&1 | FileCheck %s --implicit-check-not="{{warning|error}}:" // RUN: }}" 2>&1 | FileCheck %s --implicit-check-not="{{warning|error}}:"
// CHECK-DAG: warning: invalid configuration value 'camelback' for option 'readability-identifier-naming.FunctionCase'; did you mean 'camelBack'? [clang-tidy-config] // CHECK-DAG: warning: invalid configuration value 'camelback' for option 'readability-identifier-naming.FunctionCase'; did you mean 'camelBack'? [clang-tidy-config]
// CHECK-DAG: warning: invalid configuration value 'UUPER_CASE' for option 'readability-identifier-naming.ClassCase'; did you mean 'UPPER_CASE'? [clang-tidy-config] // CHECK-DAG: warning: invalid configuration value 'UUPER_CASE' for option 'readability-identifier-naming.ClassCase'; did you mean 'UPPER_CASE'? [clang-tidy-config]
// Don't try to suggest an alternative for 'CAMEL' // Don't try to suggest an alternative for 'CAMEL'
// CHECK-DAG: warning: invalid configuration value 'CAMEL' for option 'readability-identifier-naming.StructCase' [clang-tidy-config] // CHECK-DAG: warning: invalid configuration value 'CAMEL' for option 'readability-identifier-naming.StructCase' [clang-tidy-config]
// This fails on the EditDistance, but as it matches ignoring case suggest the correct value // This fails on the EditDistance, but as it matches ignoring case suggest the correct value
// CHECK-DAG: warning: invalid configuration value 'AnY_cASe' for option 'readability-identifier-naming.EnumCase'; did you mean 'aNy_CasE'? [clang-tidy-config] // CHECK-DAG: warning: invalid configuration value 'AnY_cASe' for option 'readability-identifier-naming.EnumCase'; did you mean 'aNy_CasE'? [clang-tidy-config]

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

// RUN: %check_clang_tidy %s readability-identifier-naming %t -- \ // RUN: %check_clang_tidy %s readability-identifier-naming %t -- \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: { \
// RUN: {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ParameterCase: CamelCase, \
// RUN: {key: readability-identifier-naming.ParameterIgnoredRegexp, value: '^[a-z]{1,2}$'}, \ // RUN: readability-identifier-naming.ParameterIgnoredRegexp: '^[a-z]{1,2}$', \
// RUN: {key: readability-identifier-naming.ClassCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ClassCase: CamelCase, \
// RUN: {key: readability-identifier-naming.ClassIgnoredRegexp, value: '^fo$|^fooo$'}, \ // RUN: readability-identifier-naming.ClassIgnoredRegexp: '^fo$|^fooo$', \
// RUN: {key: readability-identifier-naming.StructCase, value: CamelCase}, \ // RUN: readability-identifier-naming.StructCase: CamelCase, \
// RUN: {key: readability-identifier-naming.StructIgnoredRegexp, value: 'sooo|so|soo|$invalidregex['} \ // RUN: readability-identifier-naming.StructIgnoredRegexp: 'sooo|so|soo|$invalidregex[' \
// RUN: ]}" // RUN: }}"
int testFunc(int a, char **b); int testFunc(int a, char **b);
int testFunc(int ab, char **ba); int testFunc(int ab, char **ba);
int testFunc(int abc, char **cba); int testFunc(int abc, char **cba);
// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'abc' // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'abc'
// CHECK-MESSAGES: :[[@LINE-2]]:30: warning: invalid case style for parameter 'cba' // CHECK-MESSAGES: :[[@LINE-2]]:30: warning: invalid case style for parameter 'cba'
// CHECK-FIXES: {{^}}int testFunc(int Abc, char **Cba);{{$}} // CHECK-FIXES: {{^}}int testFunc(int Abc, char **Cba);{{$}}
int testFunc(int dE, char **eD); int testFunc(int dE, char **eD);
Show All 30 Lines

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

// RUN: %check_clang_tidy %s readability-identifier-naming %t -- \ // RUN: %check_clang_tidy %s readability-identifier-naming %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ParameterCase: CamelCase, \
// RUN: {key: readability-identifier-naming.IgnoreMainLikeFunctions, value: true} \ // RUN: readability-identifier-naming.IgnoreMainLikeFunctions: true \
// RUN: ]}' // RUN: }}'
int mainLike(int argc, char **argv); int mainLike(int argc, char **argv);
int mainLike(int argc, char **argv, const char **env); int mainLike(int argc, char **argv, const char **env);
int mainLike(int argc, const char **argv); int mainLike(int argc, const char **argv);
int mainLike(int argc, const char **argv, const char **env); int mainLike(int argc, const char **argv, const char **env);
int mainLike(int argc, char *argv[]); int mainLike(int argc, char *argv[]);
int mainLike(int argc, const char *argv[]); int mainLike(int argc, const char *argv[]);
int mainLike(int argc, char *argv[], char *env[]); int mainLike(int argc, char *argv[], char *env[]);
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-member-decl-usage.cpp

// RUN: %check_clang_tidy %s readability-identifier-naming %t -- \ // RUN: %check_clang_tidy %s readability-identifier-naming %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: readability-identifier-naming.MemberCase, value: CamelCase}, \ // RUN: readability-identifier-naming.MemberCase: CamelCase, \
// RUN: {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ParameterCase: CamelCase, \
// RUN: {key: readability-identifier-naming.MethodCase, value: camelBack}, \ // RUN: readability-identifier-naming.MethodCase: camelBack, \
// RUN: {key: readability-identifier-naming.AggressiveDependentMemberLookup, value: true} \ // RUN: readability-identifier-naming.AggressiveDependentMemberLookup: true \
// RUN: ]}' -- -fno-delayed-template-parsing // RUN: }}' -- -fno-delayed-template-parsing
int set_up(int); int set_up(int);
int clear(int); int clear(int);
class Foo { class Foo {
public: public:
const int bar_baz; // comment-0 const int bar_baz; // comment-0
// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for member 'bar_baz' // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for member 'bar_baz'
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

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

// Setup header directory // Setup header directory
// RUN: rm -rf %theaders // RUN: rm -rf %theaders
// RUN: mkdir %theaders // RUN: mkdir %theaders
// RUN: cp -R %S/Inputs/identifier-naming/. %theaders // RUN: cp -R %S/Inputs/identifier-naming/. %theaders
// C++11 isn't explicitly required, but failing to specify a standard means the // C++11 isn't explicitly required, but failing to specify a standard means the
// check will run multiple times for different standards. This will cause the // check will run multiple times for different standards. This will cause the
// second test to fail as the header file will be changed during the first run. // second test to fail as the header file will be changed during the first run.
// InheritParentConfig is needed to look for the clang-tidy configuration files. // InheritParentConfig is needed to look for the clang-tidy configuration files.
// RUN: %check_clang_tidy -check-suffixes=ENABLED,SHARED -std=c++11 %s \ // RUN: %check_clang_tidy -check-suffixes=ENABLED,SHARED -std=c++11 %s \
// RUN: readability-identifier-naming %t -- \ // RUN: readability-identifier-naming %t -- \
// RUN: -config='{ InheritParentConfig: true, CheckOptions: [ \ // RUN: -config='{ InheritParentConfig: true, CheckOptions: { \
// RUN: {key: readability-identifier-naming.FunctionCase, value: camelBack}, \ // RUN: readability-identifier-naming.FunctionCase: camelBack, \
// RUN: {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ParameterCase: CamelCase, \
// RUN: {key: readability-identifier-naming.GetConfigPerFile, value: true} \ // RUN: readability-identifier-naming.GetConfigPerFile: true \
// RUN: ]}' -header-filter='.*' -- -I%theaders // RUN: }}' -header-filter='.*' -- -I%theaders
// On DISABLED run, everything should be made 'camelBack'. // On DISABLED run, everything should be made 'camelBack'.
// RUN: cp -R %S/Inputs/identifier-naming/. %theaders // RUN: cp -R %S/Inputs/identifier-naming/. %theaders
// RUN: %check_clang_tidy -check-suffixes=DISABLED,SHARED -std=c++11 %s \ // RUN: %check_clang_tidy -check-suffixes=DISABLED,SHARED -std=c++11 %s \
// RUN: readability-identifier-naming %t -- \ // RUN: readability-identifier-naming %t -- \
// RUN: -config='{ InheritParentConfig: false, CheckOptions: [ \ // RUN: -config='{ InheritParentConfig: false, CheckOptions: { \
// RUN: {key: readability-identifier-naming.FunctionCase, value: camelBack}, \ // RUN: readability-identifier-naming.FunctionCase: camelBack, \
// RUN: {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ParameterCase: CamelCase, \
// RUN: {key: readability-identifier-naming.GetConfigPerFile, value: false} \ // RUN: readability-identifier-naming.GetConfigPerFile: false \
// RUN: ]}' -header-filter='.*' -- -I%theaders // RUN: }}' -header-filter='.*' -- -I%theaders
#include "global-style1/header.h" #include "global-style1/header.h"
#include "global-style2/header.h" #include "global-style2/header.h"
void goodStyle() { void goodStyle() {
style_first_good(); style_first_good();
STYLE_SECOND_GOOD(); STYLE_SECOND_GOOD();
// CHECK-FIXES-DISABLED: styleFirstGood(); // CHECK-FIXES-DISABLED: styleFirstGood();
Show All 25 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-objc.m

// RUN: %check_clang_tidy %s readability-identifier-naming %t \ // RUN: %check_clang_tidy %s readability-identifier-naming %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-identifier-naming.ObjcIvarPrefix, value: '_'}]}' \ // RUN: {readability-identifier-naming.ObjcIvarPrefix: '_'}}' \
// RUN: -- // RUN: --
@interface Foo { @interface Foo {
int _bar; int _bar;
int barWithoutPrefix; int barWithoutPrefix;
// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for objc ivar 'barWithoutPrefix' [readability-identifier-naming] // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for objc ivar 'barWithoutPrefix' [readability-identifier-naming]
// CHECK-FIXES: int _barWithoutPrefix; // CHECK-FIXES: int _barWithoutPrefix;
} }
@end @end

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

// Remove UNSUPPORTED for powerpc64le when the problem introduced by // Remove UNSUPPORTED for powerpc64le when the problem introduced by
// r288563 is resolved. // r288563 is resolved.
// UNSUPPORTED: powerpc64le // UNSUPPORTED: powerpc64le
// RUN: %check_clang_tidy %s readability-identifier-naming %t -- \ // RUN: %check_clang_tidy %s readability-identifier-naming %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: { \
// RUN: {key: readability-identifier-naming.AbstractClassCase, value: CamelCase}, \ // RUN: readability-identifier-naming.AbstractClassCase: CamelCase, \
// RUN: {key: readability-identifier-naming.AbstractClassPrefix, value: 'A'}, \ // RUN: readability-identifier-naming.AbstractClassPrefix: 'A', \
// RUN: {key: readability-identifier-naming.ClassCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ClassCase: CamelCase, \
// RUN: {key: readability-identifier-naming.ClassPrefix, value: 'C'}, \ // RUN: readability-identifier-naming.ClassPrefix: 'C', \
// RUN: {key: readability-identifier-naming.ClassConstantCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ClassConstantCase: CamelCase, \
// RUN: {key: readability-identifier-naming.ClassConstantPrefix, value: 'k'}, \ // RUN: readability-identifier-naming.ClassConstantPrefix: 'k', \
// RUN: {key: readability-identifier-naming.ClassMemberCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ClassMemberCase: CamelCase, \
// RUN: {key: readability-identifier-naming.ClassMethodCase, value: camelBack}, \ // RUN: readability-identifier-naming.ClassMethodCase: camelBack, \
// RUN: {key: readability-identifier-naming.ConstantCase, value: UPPER_CASE}, \ // RUN: readability-identifier-naming.ConstantCase: UPPER_CASE, \
// RUN: {key: readability-identifier-naming.ConstantSuffix, value: '_CST'}, \ // RUN: readability-identifier-naming.ConstantSuffix: '_CST', \
// RUN: {key: readability-identifier-naming.ConstexprFunctionCase, value: lower_case}, \ // RUN: readability-identifier-naming.ConstexprFunctionCase: lower_case, \
// RUN: {key: readability-identifier-naming.ConstexprMethodCase, value: lower_case}, \ // RUN: readability-identifier-naming.ConstexprMethodCase: lower_case, \
// RUN: {key: readability-identifier-naming.ConstexprVariableCase, value: lower_case}, \ // RUN: readability-identifier-naming.ConstexprVariableCase: lower_case, \
// RUN: {key: readability-identifier-naming.EnumCase, value: CamelCase}, \ // RUN: readability-identifier-naming.EnumCase: CamelCase, \
// RUN: {key: readability-identifier-naming.EnumPrefix, value: 'E'}, \ // RUN: readability-identifier-naming.EnumPrefix: 'E', \
// RUN: {key: readability-identifier-naming.ScopedEnumConstantCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ScopedEnumConstantCase: CamelCase, \
// RUN: {key: readability-identifier-naming.EnumConstantCase, value: UPPER_CASE}, \ // RUN: readability-identifier-naming.EnumConstantCase: UPPER_CASE, \
// RUN: {key: readability-identifier-naming.FunctionCase, value: camelBack}, \ // RUN: readability-identifier-naming.FunctionCase: camelBack, \
// RUN: {key: readability-identifier-naming.GlobalConstantCase, value: UPPER_CASE}, \ // RUN: readability-identifier-naming.GlobalConstantCase: UPPER_CASE, \
// RUN: {key: readability-identifier-naming.GlobalFunctionCase, value: CamelCase}, \ // RUN: readability-identifier-naming.GlobalFunctionCase: CamelCase, \
// RUN: {key: readability-identifier-naming.GlobalVariableCase, value: lower_case}, \ // RUN: readability-identifier-naming.GlobalVariableCase: lower_case, \
// RUN: {key: readability-identifier-naming.GlobalVariablePrefix, value: 'g_'}, \ // RUN: readability-identifier-naming.GlobalVariablePrefix: 'g_', \
// RUN: {key: readability-identifier-naming.InlineNamespaceCase, value: lower_case}, \ // RUN: readability-identifier-naming.InlineNamespaceCase: lower_case, \
// RUN: {key: readability-identifier-naming.LocalConstantCase, value: CamelCase}, \ // RUN: readability-identifier-naming.LocalConstantCase: CamelCase, \
// RUN: {key: readability-identifier-naming.LocalConstantPrefix, value: 'k'}, \ // RUN: readability-identifier-naming.LocalConstantPrefix: 'k', \
// RUN: {key: readability-identifier-naming.LocalVariableCase, value: lower_case}, \ // RUN: readability-identifier-naming.LocalVariableCase: lower_case, \
// RUN: {key: readability-identifier-naming.MemberCase, value: CamelCase}, \ // RUN: readability-identifier-naming.MemberCase: CamelCase, \
// RUN: {key: readability-identifier-naming.MemberPrefix, value: 'm_'}, \ // RUN: readability-identifier-naming.MemberPrefix: 'm_', \
// RUN: {key: readability-identifier-naming.ConstantMemberCase, value: lower_case}, \ // RUN: readability-identifier-naming.ConstantMemberCase: lower_case, \
// RUN: {key: readability-identifier-naming.PrivateMemberPrefix, value: '__'}, \ // RUN: readability-identifier-naming.PrivateMemberPrefix: '__', \
// RUN: {key: readability-identifier-naming.ProtectedMemberPrefix, value: '_'}, \ // RUN: readability-identifier-naming.ProtectedMemberPrefix: '_', \
// RUN: {key: readability-identifier-naming.PublicMemberCase, value: lower_case}, \ // RUN: readability-identifier-naming.PublicMemberCase: lower_case, \
// RUN: {key: readability-identifier-naming.MethodCase, value: camelBack}, \ // RUN: readability-identifier-naming.MethodCase: camelBack, \
// RUN: {key: readability-identifier-naming.PrivateMethodPrefix, value: '__'}, \ // RUN: readability-identifier-naming.PrivateMethodPrefix: '__', \
// RUN: {key: readability-identifier-naming.ProtectedMethodPrefix, value: '_'}, \ // RUN: readability-identifier-naming.ProtectedMethodPrefix: '_', \
// RUN: {key: readability-identifier-naming.NamespaceCase, value: lower_case}, \ // RUN: readability-identifier-naming.NamespaceCase: lower_case, \
// RUN: {key: readability-identifier-naming.ParameterCase, value: camelBack}, \ // RUN: readability-identifier-naming.ParameterCase: camelBack, \
// RUN: {key: readability-identifier-naming.ParameterPrefix, value: 'a_'}, \ // RUN: readability-identifier-naming.ParameterPrefix: 'a_', \
// RUN: {key: readability-identifier-naming.ConstantParameterCase, value: camelBack}, \ // RUN: readability-identifier-naming.ConstantParameterCase: camelBack, \
// RUN: {key: readability-identifier-naming.ConstantParameterPrefix, value: 'i_'}, \ // RUN: readability-identifier-naming.ConstantParameterPrefix: 'i_', \
// RUN: {key: readability-identifier-naming.ParameterPackCase, value: camelBack}, \ // RUN: readability-identifier-naming.ParameterPackCase: camelBack, \
// RUN: {key: readability-identifier-naming.PureFunctionCase, value: lower_case}, \ // RUN: readability-identifier-naming.PureFunctionCase: lower_case, \
// RUN: {key: readability-identifier-naming.PureMethodCase, value: camelBack}, \ // RUN: readability-identifier-naming.PureMethodCase: camelBack, \
// RUN: {key: readability-identifier-naming.StaticConstantCase, value: UPPER_CASE}, \ // RUN: readability-identifier-naming.StaticConstantCase: UPPER_CASE, \
// RUN: {key: readability-identifier-naming.StaticVariableCase, value: camelBack}, \ // RUN: readability-identifier-naming.StaticVariableCase: camelBack, \
// RUN: {key: readability-identifier-naming.StaticVariablePrefix, value: 's_'}, \ // RUN: readability-identifier-naming.StaticVariablePrefix: 's_', \
// RUN: {key: readability-identifier-naming.StructCase, value: lower_case}, \ // RUN: readability-identifier-naming.StructCase: lower_case, \
// RUN: {key: readability-identifier-naming.TemplateParameterCase, value: UPPER_CASE}, \ // RUN: readability-identifier-naming.TemplateParameterCase: UPPER_CASE, \
// RUN: {key: readability-identifier-naming.TemplateTemplateParameterCase, value: CamelCase}, \ // RUN: readability-identifier-naming.TemplateTemplateParameterCase: CamelCase, \
// RUN: {key: readability-identifier-naming.TemplateUsingCase, value: lower_case}, \ // RUN: readability-identifier-naming.TemplateUsingCase: lower_case, \
// RUN: {key: readability-identifier-naming.TemplateUsingPrefix, value: 'u_'}, \ // RUN: readability-identifier-naming.TemplateUsingPrefix: 'u_', \
// RUN: {key: readability-identifier-naming.TypeTemplateParameterCase, value: camelBack}, \ // RUN: readability-identifier-naming.TypeTemplateParameterCase: camelBack, \
// RUN: {key: readability-identifier-naming.TypeTemplateParameterSuffix, value: '_t'}, \ // RUN: readability-identifier-naming.TypeTemplateParameterSuffix: '_t', \
// RUN: {key: readability-identifier-naming.TypedefCase, value: lower_case}, \ // RUN: readability-identifier-naming.TypedefCase: lower_case, \
// RUN: {key: readability-identifier-naming.TypedefSuffix, value: '_t'}, \ // RUN: readability-identifier-naming.TypedefSuffix: '_t', \
// RUN: {key: readability-identifier-naming.UnionCase, value: CamelCase}, \ // RUN: readability-identifier-naming.UnionCase: CamelCase, \
// RUN: {key: readability-identifier-naming.UnionPrefix, value: 'U'}, \ // RUN: readability-identifier-naming.UnionPrefix: 'U', \
// RUN: {key: readability-identifier-naming.UsingCase, value: lower_case}, \ // RUN: readability-identifier-naming.UsingCase: lower_case, \
// RUN: {key: readability-identifier-naming.ValueTemplateParameterCase, value: camelBack}, \ // RUN: readability-identifier-naming.ValueTemplateParameterCase: camelBack, \
// RUN: {key: readability-identifier-naming.VariableCase, value: lower_case}, \ // RUN: readability-identifier-naming.VariableCase: lower_case, \
// RUN: {key: readability-identifier-naming.VirtualMethodCase, value: Camel_Snake_Case}, \ // RUN: readability-identifier-naming.VirtualMethodCase: Camel_Snake_Case, \
// RUN: {key: readability-identifier-naming.VirtualMethodPrefix, value: 'v_'}, \ // RUN: readability-identifier-naming.VirtualMethodPrefix: 'v_', \
// RUN: {key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE}, \ // RUN: readability-identifier-naming.MacroDefinitionCase: UPPER_CASE, \
// RUN: {key: readability-identifier-naming.TypeAliasCase, value: camel_Snake_Back}, \ // RUN: readability-identifier-naming.TypeAliasCase: camel_Snake_Back, \
// RUN: {key: readability-identifier-naming.TypeAliasSuffix, value: '_t'}, \ // RUN: readability-identifier-naming.TypeAliasSuffix: '_t', \
// RUN: {key: readability-identifier-naming.IgnoreFailedSplit, value: false}, \ // RUN: readability-identifier-naming.IgnoreFailedSplit: false, \
// RUN: {key: readability-identifier-naming.GlobalPointerCase, value: CamelCase}, \ // RUN: readability-identifier-naming.GlobalPointerCase: CamelCase, \
// RUN: {key: readability-identifier-naming.GlobalPointerSuffix, value: '_Ptr'}, \ // RUN: readability-identifier-naming.GlobalPointerSuffix: '_Ptr', \
// RUN: {key: readability-identifier-naming.GlobalConstantPointerCase, value: UPPER_CASE}, \ // RUN: readability-identifier-naming.GlobalConstantPointerCase: UPPER_CASE, \
// RUN: {key: readability-identifier-naming.GlobalConstantPointerSuffix, value: '_Ptr'}, \ // RUN: readability-identifier-naming.GlobalConstantPointerSuffix: '_Ptr', \
// RUN: {key: readability-identifier-naming.PointerParameterCase, value: lower_case}, \ // RUN: readability-identifier-naming.PointerParameterCase: lower_case, \
// RUN: {key: readability-identifier-naming.PointerParameterPrefix, value: 'p_'}, \ // RUN: readability-identifier-naming.PointerParameterPrefix: 'p_', \
// RUN: {key: readability-identifier-naming.ConstantPointerParameterCase, value: CamelCase}, \ // RUN: readability-identifier-naming.ConstantPointerParameterCase: CamelCase, \
// RUN: {key: readability-identifier-naming.ConstantPointerParameterPrefix, value: 'cp_'}, \ // RUN: readability-identifier-naming.ConstantPointerParameterPrefix: 'cp_', \
// RUN: {key: readability-identifier-naming.LocalPointerCase, value: CamelCase}, \ // RUN: readability-identifier-naming.LocalPointerCase: CamelCase, \
// RUN: {key: readability-identifier-naming.LocalPointerPrefix, value: 'l_'}, \ // RUN: readability-identifier-naming.LocalPointerPrefix: 'l_', \
// RUN: {key: readability-identifier-naming.LocalConstantPointerCase, value: CamelCase}, \ // RUN: readability-identifier-naming.LocalConstantPointerCase: CamelCase, \
// RUN: {key: readability-identifier-naming.LocalConstantPointerPrefix, value: 'lc_'}, \ // RUN: readability-identifier-naming.LocalConstantPointerPrefix: 'lc_', \
// RUN: ]}' -- -fno-delayed-template-parsing -Dbad_macro -std=c++17 -fcoroutines-ts \ // RUN: }}' -- -fno-delayed-template-parsing -Dbad_macro -std=c++17 -fcoroutines-ts \
// RUN: -I%S/Inputs/identifier-naming \ // RUN: -I%S/Inputs/identifier-naming \
// RUN: -isystem %S/Inputs/identifier-naming/system // RUN: -isystem %S/Inputs/identifier-naming/system
// clang-format off // clang-format off
#include <system-header.h> #include <system-header.h>
#include <coroutines.h> #include <coroutines.h>
#include "user-header.h" #include "user-header.h"
▲ Show 20 Lines • Show All 617 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s readability-implicit-bool-conversion %t \ // RUN: %check_clang_tidy %s readability-implicit-bool-conversion %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-implicit-bool-conversion.AllowIntegerConditions, value: true}, \ // RUN: {readability-implicit-bool-conversion.AllowIntegerConditions: true, \
// RUN: {key: readability-implicit-bool-conversion.AllowPointerConditions, value: true}]}' // RUN: readability-implicit-bool-conversion.AllowPointerConditions: true}}'
template<typename T> template<typename T>
void functionTaking(T); void functionTaking(T);
int functionReturningInt(); int functionReturningInt();
int* functionReturningPointer(); int* functionReturningPointer();
struct Struct { struct Struct {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- \ // RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- \
// RUN: -config="{CheckOptions: [{key: readability-inconsistent-declaration-parameter-name.IgnoreMacros, value: false}]}" // RUN: -config="{CheckOptions: {readability-inconsistent-declaration-parameter-name.IgnoreMacros: false}}"
#define MACRO() \ #define MACRO() \
void f(int x) void f(int x)
struct S1 { struct S1 {
MACRO(); MACRO();
// CHECK-NOTES: :[[@LINE-1]]:3: warning: function 'S1::f' has a definition with different parameter names // 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' // CHECK-NOTES: :[[@LINE-5]]:8: note: expanded from macro 'MACRO'
Show All 36 Lines

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

// RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- \ // RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- \
// RUN: -config="{CheckOptions: [{key: readability-inconsistent-declaration-parameter-name.Strict, value: true}]}" // RUN: -config="{CheckOptions: {readability-inconsistent-declaration-parameter-name.Strict: true}}"
void inconsistentFunction(int a, int b, int c); void inconsistentFunction(int a, int b, int c);
// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'inconsistentFunction' has 1 other declaration with different parameter names // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'inconsistentFunction' has 1 other declaration with different parameter names
void inconsistentFunction(int prefixA, int b, int cSuffix); void inconsistentFunction(int prefixA, int b, int cSuffix);
// CHECK-MESSAGES: :[[@LINE-1]]:6: note: the 1st inconsistent declaration seen here // 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') // 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 a, int b, int c);
void inconsistentFunction(int /*c*/, int /*c*/, int /*c*/); void inconsistentFunction(int /*c*/, int /*c*/, int /*c*/);

clang-tools-extra/test/clang-tidy/checkers/readability/magic-numbers-bitfields.cpp

// RUN: %check_clang_tidy %s readability-magic-numbers %t \ // RUN: %check_clang_tidy %s readability-magic-numbers %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-magic-numbers.IgnoredIntegerValues, value: "1;2;10;100;"}]}' \ // RUN: {readability-magic-numbers.IgnoredIntegerValues: "1;2;10;100;"}}' \
// RUN: -- // RUN: --
struct HardwareGateway { struct HardwareGateway {
/* /*
* The configuration suppresses the warnings for the bitfields... * The configuration suppresses the warnings for the bitfields...
*/ */
unsigned int Some: 5; unsigned int Some: 5;
unsigned int Bits: 7; unsigned int Bits: 7;
Show All 11 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/magic-numbers.cpp

// RUN: %check_clang_tidy %s readability-magic-numbers %t \ // RUN: %check_clang_tidy %s readability-magic-numbers %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-magic-numbers.IgnoredIntegerValues, value: "0;1;2;10;100;"}, \ // RUN: {readability-magic-numbers.IgnoredIntegerValues: "0;1;2;10;100;", \
// RUN: {key: readability-magic-numbers.IgnoredFloatingPointValues, value: "3.14;2.71828;9.81;10000.0;101.0;0x1.2p3"}, \ // RUN: readability-magic-numbers.IgnoredFloatingPointValues: "3.14;2.71828;9.81;10000.0;101.0;0x1.2p3", \
// RUN: {key: readability-magic-numbers.IgnoreBitFieldsWidths, value: false}, \ // RUN: readability-magic-numbers.IgnoreBitFieldsWidths: false, \
// RUN: {key: readability-magic-numbers.IgnorePowersOf2IntegerValues, value: true}]}' \ // RUN: readability-magic-numbers.IgnorePowersOf2IntegerValues: true}}' \
// RUN: -- // RUN: --
template <typename T, int V> template <typename T, int V>
struct ValueBucket { struct ValueBucket {
T value[V]; T value[V];
}; };
int BadGlobalInt = 5; int BadGlobalInt = 5;
▲ Show 20 Lines • Show All 214 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/redundant-access-specifiers-check-first-declaration.cpp

// RUN: %check_clang_tidy %s readability-redundant-access-specifiers %t -- \ // RUN: %check_clang_tidy %s readability-redundant-access-specifiers %t -- \
// RUN: -config="{CheckOptions: [{key: readability-redundant-access-specifiers.CheckFirstDeclaration, value: true}]}" -- // RUN: -config="{CheckOptions: {readability-redundant-access-specifiers.CheckFirstDeclaration: true}}" --
class FooPublic { class FooPublic {
private: // comment-0 private: // comment-0
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the implicit access specifier [readability-redundant-access-specifiers] // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the implicit access specifier [readability-redundant-access-specifiers]
// CHECK-FIXES: {{^}}// comment-0{{$}} // CHECK-FIXES: {{^}}// comment-0{{$}}
int a; int a;
}; };
Show All 33 Lines

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

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

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

// RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \ // RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-redundant-declaration.IgnoreMacros, \ // RUN: {readability-redundant-declaration.IgnoreMacros: \
// RUN: value: false}]}" // RUN: false}}"
// //
// With -fms-compatibility and -DEXTERNINLINE, the extern inline shouldn't // With -fms-compatibility and -DEXTERNINLINE, the extern inline shouldn't
// produce additional diagnostics, so same check suffix as before: // produce additional diagnostics, so same check suffix as before:
// RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \ // RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-redundant-declaration.IgnoreMacros, \ // RUN: {readability-redundant-declaration.IgnoreMacros: \
// RUN: value: false}]}" -- -fms-compatibility -DEXTERNINLINE // RUN: false}}" -- -fms-compatibility -DEXTERNINLINE
// //
// With -fno-ms-compatibility, DEXTERNINLINE causes additional output. // With -fno-ms-compatibility, DEXTERNINLINE causes additional output.
// (The leading ',' means "default checks in addition to NOMSCOMPAT checks.) // (The leading ',' means "default checks in addition to NOMSCOMPAT checks.)
// RUN: %check_clang_tidy -check-suffix=,NOMSCOMPAT \ // RUN: %check_clang_tidy -check-suffix=,NOMSCOMPAT \
// RUN: %s readability-redundant-declaration %t -- \ // RUN: %s readability-redundant-declaration %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-redundant-declaration.IgnoreMacros, \ // RUN: {readability-redundant-declaration.IgnoreMacros: \
// RUN: value: false}]}" -- -fno-ms-compatibility -DEXTERNINLINE // RUN: false}}" -- -fno-ms-compatibility -DEXTERNINLINE
extern int Xyz; extern int Xyz;
extern int Xyz; // Xyz extern int Xyz; // Xyz
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Xyz' declaration [readability-redundant-declaration] // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Xyz' declaration [readability-redundant-declaration]
// CHECK-FIXES: {{^}}// Xyz{{$}} // CHECK-FIXES: {{^}}// Xyz{{$}}
int Xyz = 123; int Xyz = 123;
extern int A; extern int A;
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s readability-redundant-member-init %t \ // RUN: %check_clang_tidy %s readability-redundant-member-init %t \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-redundant-member-init.IgnoreBaseInCopyConstructors, \ // RUN: {readability-redundant-member-init.IgnoreBaseInCopyConstructors: \
// RUN: value: true}] \ // RUN: true} \
// RUN: }" // RUN: }"
struct S { struct S {
S() = default; S() = default;
S(int i) : i(i) {} S(int i) : i(i) {}
int i = 1; int i = 1;
}; };
▲ Show 20 Lines • Show All 240 Lines • Show Last 20 Lines

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

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

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

// RUN: %check_clang_tidy %s readability-redundant-string-init %t \ // RUN: %check_clang_tidy %s readability-redundant-string-init %t \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-redundant-string-init.StringNames, \ // RUN: {readability-redundant-string-init.StringNames: \
// RUN: value: '::std::basic_string;::std::basic_string_view;our::TestString'}] \ // RUN: '::std::basic_string;::std::basic_string_view;our::TestString'} \
// RUN: }" // RUN: }"
namespace std { namespace std {
template <typename T> template <typename T>
class allocator {}; class allocator {};
template <typename T> template <typename T>
class char_traits {}; class char_traits {};
template <typename C, typename T = std::char_traits<C>, typename A = std::allocator<C>> template <typename C, typename T = std::char_traits<C>, typename A = std::allocator<C>>
▲ Show 20 Lines • Show All 339 Lines • Show Last 20 Lines

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

// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalAssignment", value: true}]}" -- // RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- -config="{CheckOptions: {readability-simplify-boolean-expr.ChainedConditionalAssignment: true}}" --
void chained_conditional_compound_assignment(int i) { void chained_conditional_compound_assignment(int i) {
bool b; bool b;
if (i < 0) { if (i < 0) {
b = true; b = true;
} else if (i < 10) { } else if (i < 10) {
b = false; b = false;
} else if (i > 20) { } else if (i > 20) {
Show All 25 Lines

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

// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalReturn", value: true}]}" -- // RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- -config="{CheckOptions: {readability-simplify-boolean-expr.ChainedConditionalReturn: true}}" --
bool chained_conditional_compound_return(int i) { bool chained_conditional_compound_return(int i) {
if (i < 0) { if (i < 0) {
return true; return true;
} else if (i < 10) { } else if (i < 10) {
return false; return false;
} else if (i > 20) { } else if (i > 20) {
return true; return true;
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/simplify-bool-expr-demorgan.cpp

// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t // RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t
// Check when we can convert !(A Op B) -> !A InvOp !B. // Check when we can convert !(A Op B) -> !A InvOp !B.
// RUN: %check_clang_tidy -check-suffixes=",RELAXED" %s \ // RUN: %check_clang_tidy -check-suffixes=",RELAXED" %s \
// RUN: readability-simplify-boolean-expr %t -- -config="{CheckOptions: [{ \ // RUN: readability-simplify-boolean-expr %t -- -config="{CheckOptions: { \
// RUN: key: "readability-simplify-boolean-expr.SimplifyDeMorganRelaxed", value: true}]}" -- // RUN: readability-simplify-boolean-expr.SimplifyDeMorganRelaxed: true}}" --
// Verify warning issued when invalid options are specified. // Verify warning issued when invalid options are specified.
// RUN: clang-tidy %s -checks=-*,readability-simplify-boolean-expr -config="{CheckOptions: [ \ // RUN: clang-tidy %s -checks=-*,readability-simplify-boolean-expr -config="{CheckOptions: { \
// RUN: {key: readability-simplify-boolean-expr.SimplifyDeMorgan, value: false}, \ // RUN: readability-simplify-boolean-expr.SimplifyDeMorgan: false, \
// RUN: {key: readability-simplify-boolean-expr.SimplifyDeMorganRelaxed, value: true}]}" \ // RUN: readability-simplify-boolean-expr.SimplifyDeMorganRelaxed: true}}" \
// RUN: -- 2>&1 | FileCheck %s -check-prefix=CHECK-BAD-CONFIG \ // RUN: -- 2>&1 | FileCheck %s -check-prefix=CHECK-BAD-CONFIG \
// RUN: -implicit-check-not="{{warning|error}}:" // RUN: -implicit-check-not="{{warning|error}}:"
// CHECK-BAD-CONFIG: warning: readability-simplify-boolean-expr: 'SimplifyDeMorganRelaxed' cannot be enabled without 'SimplifyDeMorgan' enabled // CHECK-BAD-CONFIG: warning: readability-simplify-boolean-expr: 'SimplifyDeMorganRelaxed' cannot be enabled without 'SimplifyDeMorgan' enabled
void eat(bool); void eat(bool);
void foo(bool A1, bool A2, bool A3, bool A4) { void foo(bool A1, bool A2, bool A3, bool A4) {
bool X; bool X;
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/simplify-subscript-expr.cpp

// RUN: %check_clang_tidy %s readability-simplify-subscript-expr %t \ // RUN: %check_clang_tidy %s readability-simplify-subscript-expr %t \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-simplify-subscript-expr.Types, \ // RUN: {readability-simplify-subscript-expr.Types: \
// RUN: value: '::std::basic_string;::std::basic_string_view;MyVector'}]}" -- // RUN: '::std::basic_string;::std::basic_string_view;MyVector'}}" --
namespace std { namespace std {
template <class T> template <class T>
class basic_string { class basic_string {
public: public:
using size_type = unsigned; using size_type = unsigned;
using value_type = T; using value_type = T;
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/static-accessed-through-instance-nesting-threshold.cpp

// RUN: %check_clang_tidy %s readability-static-accessed-through-instance %t -- -config="{CheckOptions: [{key: readability-static-accessed-through-instance.NameSpecifierNestingThreshold, value: 4}]}" -- // RUN: %check_clang_tidy %s readability-static-accessed-through-instance %t -- -config="{CheckOptions: {readability-static-accessed-through-instance.NameSpecifierNestingThreshold: 4}}" --
// Nested specifiers // Nested specifiers
namespace M { namespace M {
namespace N { namespace N {
struct V { struct V {
static int v; static int v;
struct T { struct T {
static int t; static int t;
Show All 24 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/uniqueptr-delete-release.cpp

// RUN: %check_clang_tidy %s readability-uniqueptr-delete-release %t -check-suffix=NULLPTR // RUN: %check_clang_tidy %s readability-uniqueptr-delete-release %t -check-suffix=NULLPTR
// RUN: %check_clang_tidy %s readability-uniqueptr-delete-release %t -check-suffix=RESET -config='{ \ // RUN: %check_clang_tidy %s readability-uniqueptr-delete-release %t -check-suffix=RESET -config='{ \
// RUN: CheckOptions: [{key: readability-uniqueptr-delete-release.PreferResetCall, value: true}]}' // RUN: CheckOptions: {readability-uniqueptr-delete-release.PreferResetCall: true}}'
namespace std { namespace std {
template <typename T> template <typename T>
struct default_delete {}; struct default_delete {};
template <typename T, typename D = default_delete<T>> template <typename T, typename D = default_delete<T>>
class unique_ptr { class unique_ptr {
public: public:
unique_ptr(); unique_ptr();
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-integer-custom-list.cpp

// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -config="{CheckOptions: [{key: readability-uppercase-literal-suffix.NewSuffixes, value: 'L;uL'}]}" -- -I %clang_tidy_headers // RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -config="{CheckOptions: {readability-uppercase-literal-suffix.NewSuffixes: 'L;uL'}}" -- -I %clang_tidy_headers
// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp // RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -config="{CheckOptions: [{key: readability-uppercase-literal-suffix.NewSuffixes, value: 'L;uL'}]}" -- -I %clang_tidy_headers // RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -fix -config="{CheckOptions: {readability-uppercase-literal-suffix.NewSuffixes: 'L;uL'}}" -- -I %clang_tidy_headers
// RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -config="{CheckOptions: [{key: readability-uppercase-literal-suffix.NewSuffixes, value: 'L;uL'}]}" -- -I %clang_tidy_headers // RUN: clang-tidy %t.cpp -checks='-*,readability-uppercase-literal-suffix' -warnings-as-errors='-*,readability-uppercase-literal-suffix' -config="{CheckOptions: {readability-uppercase-literal-suffix.NewSuffixes: 'L;uL'}}" -- -I %clang_tidy_headers
#include "integral_constant.h" #include "integral_constant.h"
void integer_suffix() { void integer_suffix() {
// Unsigned // Unsigned
static constexpr auto v3 = 1u; // OK. static constexpr auto v3 = 1u; // OK.
static_assert(is_same<decltype(v3), const unsigned int>::value, ""); static_assert(is_same<decltype(v3), const unsigned int>::value, "");
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability/uppercase-literal-suffix-integer-macro.cpp

// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- \ // RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- \
// RUN: -config="{CheckOptions: [{key: readability-uppercase-literal-suffix.IgnoreMacros, value: false}]}" \ // RUN: -config="{CheckOptions: {readability-uppercase-literal-suffix.IgnoreMacros: false}}" \
// RUN: -- -I %S // RUN: -- -I %S
void macros() { void macros() {
#define INMACRO(X) 1.f #define INMACRO(X) 1.f
static constexpr auto m1 = INMACRO(); static constexpr auto m1 = INMACRO();
// CHECK-NOTES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase // CHECK-NOTES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
// CHECK-NOTES: :[[@LINE-3]]:20: note: expanded from macro 'INMACRO' // CHECK-NOTES: :[[@LINE-3]]:20: note: expanded from macro 'INMACRO'
// CHECK-FIXES: #define INMACRO(X) 1.f // CHECK-FIXES: #define INMACRO(X) 1.f
Show All 17 Lines

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

// RUN: %check_clang_tidy %s zircon-temporary-objects %t -- \ // RUN: %check_clang_tidy %s zircon-temporary-objects %t -- \
// RUN: -config="{CheckOptions: [{key: zircon-temporary-objects.Names, value: 'Foo;NS::Bar'}]}" \ // RUN: -config="{CheckOptions: {zircon-temporary-objects.Names: 'Foo;NS::Bar'}}" \
// RUN: -header-filter=.* // RUN: -header-filter=.*
// Should flag instances of Foo, NS::Bar. // Should flag instances of Foo, NS::Bar.
class Foo { class Foo {
public: public:
Foo() = default; Foo() = default;
Foo(int Val) : Val(Val){}; Foo(int Val) : Val(Val){};
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/infrastructure/duplicate-conflicted-fixes-of-alias-checkers.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init,hicpp-member-init,modernize-use-emplace,hicpp-use-emplace %t -- \ // RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init,hicpp-member-init,modernize-use-emplace,hicpp-use-emplace %t -- \
//// RUN: -config='{CheckOptions: [ \ //// RUN: -config='{CheckOptions: { \
//// RUN: {key: cppcoreguidelines-pro-type-member-init.UseAssignment, value: true}, \ //// RUN: cppcoreguidelines-pro-type-member-init.UseAssignment: true, \
//// RUN: ]}' //// RUN: }}'
class Foo { class Foo {
public: public:
Foo() : _num1(0) Foo() : _num1(0)
// CHECK-MESSAGES: warning: constructor does not initialize these fields: _num2 [cppcoreguidelines-pro-type-member-init,hicpp-member-init] // CHECK-MESSAGES: warning: constructor does not initialize these fields: _num2 [cppcoreguidelines-pro-type-member-init,hicpp-member-init]
// CHECK-MESSAGES: note: cannot apply fix-it because an alias checker has suggested a different fix-it; please remove one of the checkers ('cppcoreguidelines-pro-type-member-init', 'hicpp-member-init') or ensure they are both configured the same // CHECK-MESSAGES: note: cannot apply fix-it because an alias checker has suggested a different fix-it; please remove one of the checkers ('cppcoreguidelines-pro-type-member-init', 'hicpp-member-init') or ensure they are both configured the same
{ {
_num1 = 10; _num1 = 10;
Show All 11 Lines

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

// Sanity-check. Run without modules: // Sanity-check. Run without modules:
// RUN: rm -rf %t // RUN: rm -rf %t
// RUN: mkdir %t // RUN: mkdir %t
// RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/ // RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/
// RUN: %check_clang_tidy -std=c++11 %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: -config="CheckOptions: { \
// RUN: key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \ // RUN: readability-identifier-naming.MacroDefinitionCase: UPPER_CASE }" \
// RUN: -header-filter=.* \ // RUN: -header-filter=.* \
// RUN: -- -I %t/ // RUN: -- -I %t/
// //
// RUN: rm -rf %t // RUN: rm -rf %t
// RUN: mkdir %t // RUN: mkdir %t
// RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %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: %check_clang_tidy -std=c++17 %s readability-identifier-naming %t/without-modules -- \
// RUN: -config="CheckOptions: [{ \ // RUN: -config="CheckOptions: { \
// RUN: key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \ // RUN: readability-identifier-naming.MacroDefinitionCase: UPPER_CASE }" \
// RUN: -header-filter=.* \ // RUN: -header-filter=.* \
// RUN: -- -I %t/ // RUN: -- -I %t/
// //
// Run clang-tidy on a file with modular includes: // Run clang-tidy on a file with modular includes:
// //
// RUN: rm -rf %t // RUN: rm -rf %t
// RUN: mkdir %t // RUN: mkdir %t
// RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/ // RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %t/
// RUN: %check_clang_tidy -std=c++11 %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: -config="CheckOptions: { \
// RUN: key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \ // RUN: readability-identifier-naming.MacroDefinitionCase: UPPER_CASE }" \
// RUN: -header-filter=.* \ // RUN: -header-filter=.* \
// RUN: -- -I %t/ \ // RUN: -- -I %t/ \
// RUN: -fmodules -fimplicit-modules -fno-implicit-module-maps \ // RUN: -fmodules -fimplicit-modules -fno-implicit-module-maps \
// RUN: -fmodule-map-file=%t/module.modulemap \ // RUN: -fmodule-map-file=%t/module.modulemap \
// RUN: -fmodules-cache-path=%t/module-cache/ // RUN: -fmodules-cache-path=%t/module-cache/
// //
// RUN: rm -rf %t // RUN: rm -rf %t
// RUN: mkdir %t // RUN: mkdir %t
// RUN: cp %S/Inputs/expand-modular-headers-ppcallbacks/* %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: %check_clang_tidy -std=c++17 %s readability-identifier-naming %t/with-modules -- \
// RUN: -config="CheckOptions: [{ \ // RUN: -config="CheckOptions: { \
// RUN: key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }]" \ // RUN: readability-identifier-naming.MacroDefinitionCase: UPPER_CASE }" \
// RUN: -header-filter=.* \ // RUN: -header-filter=.* \
// RUN: -- -I %t/ \ // RUN: -- -I %t/ \
// RUN: -fmodules -fimplicit-modules -fno-implicit-module-maps \ // RUN: -fmodules -fimplicit-modules -fno-implicit-module-maps \
// RUN: -fmodule-map-file=%t/module.modulemap \ // RUN: -fmodule-map-file=%t/module.modulemap \
// RUN: -fmodules-cache-path=%t/module-cache/ // RUN: -fmodules-cache-path=%t/module-cache/
// FIXME: Make the test work in all language modes. // FIXME: Make the test work in all language modes.
#include "c.h" #include "c.h"
Show All 10 Lines

clang-tools-extra/test/clang-tidy/infrastructure/run-clang-tidy.cpp

// RUN: %run_clang_tidy --help // RUN: %run_clang_tidy --help
// RUN: rm -rf %t // RUN: rm -rf %t
// RUN: mkdir %t // RUN: mkdir %t
// RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %/t/test.cpp\",\"file\":\"%/t/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json // RUN: echo "[{\"directory\":\".\",\"command\":\"clang++ -c %/t/test.cpp\",\"file\":\"%/t/test.cpp\"}]" | sed -e 's/\\/\\\\/g' > %t/compile_commands.json
// RUN: echo "Checks: '-*,modernize-use-auto'" > %t/.clang-tidy // RUN: echo "Checks: '-*,modernize-use-auto'" > %t/.clang-tidy
// RUN: echo "WarningsAsErrors: '*'" >> %t/.clang-tidy // RUN: echo "WarningsAsErrors: '*'" >> %t/.clang-tidy
// RUN: echo "CheckOptions:" >> %t/.clang-tidy // RUN: echo "CheckOptions:" >> %t/.clang-tidy
// RUN: echo " - key: modernize-use-auto.MinTypeNameLength" >> %t/.clang-tidy // RUN: echo " modernize-use-auto.MinTypeNameLength: '0'" >> %t/.clang-tidy
// RUN: echo " value: '0'" >> %t/.clang-tidy
// RUN: cp "%s" "%t/test.cpp" // RUN: cp "%s" "%t/test.cpp"
// RUN: cd "%t" // RUN: cd "%t"
// RUN: not %run_clang_tidy "test.cpp" // RUN: not %run_clang_tidy "test.cpp"
int main() int main()
{ {
int* x = new int(); int* x = new int();
delete x; delete x;
} }

clang-tools-extra/test/clang-tidy/infrastructure/static-analyzer-config.cpp

// REQUIRES: static-analyzer // REQUIRES: static-analyzer
// RUN: clang-tidy %s -checks='-*,clang-analyzer-unix.Malloc' -config='{CheckOptions: [{ key: "clang-analyzer-unix.DynamicMemoryModeling:Optimistic", value: true}]}' -- | FileCheck %s // RUN: clang-tidy %s -checks='-*,clang-analyzer-unix.Malloc' -config='{CheckOptions: { "clang-analyzer-unix.DynamicMemoryModeling:Optimistic": true}}' -- | FileCheck %s
typedef __typeof(sizeof(int)) size_t; typedef __typeof(sizeof(int)) size_t;
void *malloc(size_t); void *malloc(size_t);
void free(void *); void free(void *);
void __attribute((ownership_returns(malloc))) *my_malloc(size_t); void __attribute((ownership_returns(malloc))) *my_malloc(size_t);
void __attribute((ownership_takes(malloc, 1))) my_free(void *); void __attribute((ownership_takes(malloc, 1))) my_free(void *);
void f1() { void f1() {
void *p = malloc(12); void *p = malloc(12);
Show All 10 Lines

clang-tools-extra/test/clang-tidy/infrastructure/verify-config.cpp

// RUN: clang-tidy -verify-config --config='' | FileCheck %s -check-prefix=CHECK-VERIFY-OK // RUN: clang-tidy -verify-config --config='' | FileCheck %s -check-prefix=CHECK-VERIFY-OK
// CHECK-VERIFY-OK: No config errors detected. // CHECK-VERIFY-OK: No config errors detected.
// RUN: not clang-tidy -verify-config \ // RUN: not clang-tidy -verify-config \
// RUN: --checks='-*,bad*glob,llvm*,llvm-includeorder,my-made-up-check' --config='{Checks: "readability-else-after-ret", \ // RUN: --checks='-*,bad*glob,llvm*,llvm-includeorder,my-made-up-check' --config='{Checks: "readability-else-after-ret", \
// RUN: CheckOptions: [{key: "IgnoreMacros", value: "true"}, \ // RUN: CheckOptions: {IgnoreMacros: "true", \
// RUN: {key: "StriceMode", value: "true"}, \ // RUN: StriceMode: "true", \
// RUN: {key: modernize-lop-convert.UseCxx20ReverseRanges, value: true} \ // RUN: modernize-lop-convert.UseCxx20ReverseRanges: true \
// RUN: ]}' 2>&1 | FileCheck %s \ // RUN: }}' 2>&1 | FileCheck %s \
// RUN: -check-prefix=CHECK-VERIFY -implicit-check-not='{{warning|error}}:' // RUN: -check-prefix=CHECK-VERIFY -implicit-check-not='{{warning|error}}:'
// CHECK-VERIFY-DAG: command-line option '-config': warning: unknown check 'readability-else-after-ret'; did you mean 'readability-else-after-return' [-verify-config] // CHECK-VERIFY-DAG: command-line option '-config': warning: unknown check 'readability-else-after-ret'; did you mean 'readability-else-after-return' [-verify-config]
// CHECK-VERIFY-DAG: command-line option '-config': warning: unknown check option 'modernize-lop-convert.UseCxx20ReverseRanges'; did you mean 'modernize-loop-convert.UseCxx20ReverseRanges' [-verify-config] // CHECK-VERIFY-DAG: command-line option '-config': warning: unknown check option 'modernize-lop-convert.UseCxx20ReverseRanges'; did you mean 'modernize-loop-convert.UseCxx20ReverseRanges' [-verify-config]
// CHECK-VERIFY-DAG: command-line option '-config': warning: unknown check option 'StriceMode'; did you mean 'StrictMode' [-verify-config] // CHECK-VERIFY-DAG: command-line option '-config': warning: unknown check option 'StriceMode'; did you mean 'StrictMode' [-verify-config]
// CHECK-VERIFY: command-line option '-checks': warning: check glob 'bad*glob' doesn't match any known check [-verify-config] // CHECK-VERIFY: command-line option '-checks': warning: check glob 'bad*glob' doesn't match any known check [-verify-config]
// CHECK-VERIFY: command-line option '-checks': warning: unknown check 'llvm-includeorder'; did you mean 'llvm-include-order' [-verify-config] // CHECK-VERIFY: command-line option '-checks': warning: unknown check 'llvm-includeorder'; did you mean 'llvm-include-order' [-verify-config]
// CHECK-VERIFY: command-line option '-checks': warning: unknown check 'my-made-up-check' [-verify-config] // CHECK-VERIFY: command-line option '-checks': warning: unknown check 'my-made-up-check' [-verify-config]