This is an archive of the discontinued LLVM Phabricator instance.

Differential D5989

[clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh
ClosedPublic

Authored by alexfh on Oct 25 2014, 7:18 PM.

Details

Reviewers
klimek
Commits
rG106c8e089868: [clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh
rCTE220634: [clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh
rL220634: [clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh
Summary

Make the script suitable for checking just messages. Move most of the tests to use it. Clean up the tests: shorten messages, insert line numbers, remove unnecessary RUN: lines, etc.

Diff Detail

Event Timeline

alexfh updated this revision to Diff 15453.Oct 25 2014, 7:18 PM
alexfh retitled this revision from to [clang-tidy] check_clang_tidy_fix.sh -> check_clang_tidy.sh.
alexfh updated this object.
alexfh edited the test plan for this revision. (Show Details)
alexfh added a reviewer: klimek.
alexfh added a subscriber: Unknown Object (MLST).
Herald added a subscriber: curdeius. · View Herald TranscriptOct 25 2014, 7:18 PM
alexfh updated this object.Oct 25 2014, 7:21 PM
alexfh updated this revision to Diff 15454.Oct 25 2014, 7:33 PM

Committed obvious unrelated changes separately.

klimek accepted this revision.Oct 25 2014, 7:58 PM
klimek edited edge metadata.

lg

This revision is now accepted and ready to land.Oct 25 2014, 7:58 PM
alexfh closed this revision.Oct 25 2014, 8:08 PM

Revision Contents

Diff 15453

test/clang-tidy/arg-comments.cpp

// RUN: clang-tidy --checks='-*,misc-argument-comment' %s -- -std=c++11 | FileCheck %s -implicit-check-not='{{warning:|error:}}' // RUN: $(dirname %s)/check_clang_tidy.sh %s misc-argument-comment %t
// REQUIRES: shell
// FIXME: clang-tidy should provide a -verify mode to make writing these checks // FIXME: clang-tidy should provide a -verify mode to make writing these checks
// easier and more accurate. // easier and more accurate.
void ffff(int xxxx, int yyyy); void ffff(int xxxx, int yyyy);
void f(int x, int y); void f(int x, int y);
void g() { void g() {
// CHECK: [[@LINE+4]]:5: warning: argument name 'y' in comment does not match parameter name 'x' // CHECK-MESSAGES: [[@LINE+4]]:5: warning: argument name 'y' in comment does not match parameter name 'x'
// CHECK: :[[@LINE-3]]:12: note: 'x' declared here // CHECK-MESSAGES: :[[@LINE-3]]:12: note: 'x' declared here
// CHECK: [[@LINE+2]]:14: warning: argument name 'z' in comment does not match parameter name 'y' // CHECK-MESSAGES: [[@LINE+2]]:14: warning: argument name 'z' in comment does not match parameter name 'y'
// CHECK: :[[@LINE-5]]:19: note: 'y' declared here // CHECK-MESSAGES: :[[@LINE-5]]:19: note: 'y' declared here
f(/*y=*/0, /*z=*/0); f(/*y=*/0, /*z=*/0);
} }
struct Closure {}; struct Closure {};
template <typename T1, typename T2> template <typename T1, typename T2>
Closure *NewCallback(void (*f)(T1, T2), T1 arg1, T2 arg2) { return nullptr; } Closure *NewCallback(void (*f)(T1, T2), T1 arg1, T2 arg2) { return nullptr; }
Show All 9 Lines
void variadic(Args&&... args); void variadic(Args&&... args);
template<typename... Args> template<typename... Args>
void variadic2(int zzz, Args&&... args); void variadic2(int zzz, Args&&... args);
void templates() { void templates() {
variadic(/*xxx=*/0, /*yyy=*/1); variadic(/*xxx=*/0, /*yyy=*/1);
variadic2(/*zzZ=*/0, /*xxx=*/1, /*yyy=*/2); variadic2(/*zzZ=*/0, /*xxx=*/1, /*yyy=*/2);
// CHECK: [[@LINE-1]]:13: warning: argument name 'zzZ' in comment does not match parameter name 'zzz' // CHECK-MESSAGES: [[@LINE-1]]:13: warning: argument name 'zzZ' in comment does not match parameter name 'zzz'
} }

test/clang-tidy/basic.cpp

// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp // RUN: clang-tidy %s -checks='-*,llvm-namespace-comment' -- | FileCheck %s
// RUN: clang-tidy %t.cpp -checks='-*,llvm-namespace-comment' -- > %t2.cpp
// RUN: FileCheck -input-file=%t2.cpp %s
namespace i { namespace i {
} }
// CHECK: warning: namespace not terminated with a closing comment [llvm-namespace-comment] // CHECK: warning: namespace not terminated with a closing comment [llvm-namespace-comment]

test/clang-tidy/check_clang_tidy.sh

  • This file was moved from test/clang-tidy/check_clang_tidy_fix.sh.
#!/bin/sh #!/bin/sh
# #
# Run clang-tidy in fix mode and verify the result. # Run clang-tidy in fix mode and verify fixes, messages or both.
# Usage: # Usage:
# check_clang_tidy_fix.sh <source-file> <check-name> <temp-file> \ # check_clang_tidy.sh <source-file> <check-name> <temp-file> \
# [optional clang-tidy arguments] # [optional clang-tidy arguments]
# #
# Example: # Example:
# // RUN: $(dirname %s)/check_clang_tidy_fix.sh %s llvm-include-order %t -- -isystem $(dirname %s)/Inputs/Headers # // RUN: $(dirname %s)/check_clang_tidy.sh %s llvm-include-order %t -- -isystem $(dirname %s)/Inputs/Headers
# // REQUIRES: shell # // REQUIRES: shell
INPUT_FILE=$1 INPUT_FILE=$1
CHECK_TO_RUN=$2 CHECK_TO_RUN=$2
TEMPORARY_FILE=$3.cpp TEMPORARY_FILE=$3.cpp
# Feed the rest arguments to clang-tidy. # Feed the rest arguments to clang-tidy.
shift 3 shift 3
if [ "$#" -eq 0 ] ; then if [ "$#" -eq 0 ] ; then
# Default to -- --std=c++11 # Default to -- --std=c++11
set - -- --std=c++11 set - -- --std=c++11
fi fi
set -o errexit set -o errexit
if ! grep -q 'CHECK-FIXES\|CHECK-MESSAGES' "${INPUT_FILE}"; then
echo "FAIL: Neither CHECK-FIXES nor CHECK-MESSAGES found in the input"
exit 1
fi
# Remove the contents of the CHECK lines to avoid CHECKs matching on themselves. # Remove the contents of the CHECK lines to avoid CHECKs matching on themselves.
# We need to keep the comments to preserve line numbers while avoiding empty # We need to keep the comments to preserve line numbers while avoiding empty
# lines which could potentially trigger formatting-related checks. # lines which could potentially trigger formatting-related checks.
sed 's#// *CHECK-[A-Z-]*:.*#//#' ${INPUT_FILE} > ${TEMPORARY_FILE} sed 's#// *CHECK-[A-Z-]*:.*#//#' "${INPUT_FILE}" > "${TEMPORARY_FILE}"
clang-tidy ${TEMPORARY_FILE} -fix --checks="-*,${CHECK_TO_RUN}" "$@" \ clang-tidy "${TEMPORARY_FILE}" -fix --checks="-*,${CHECK_TO_RUN}" "$@" \
> ${TEMPORARY_FILE}.msg 2>&1 > "${TEMPORARY_FILE}.msg" 2>&1
FileCheck -input-file=${TEMPORARY_FILE} ${INPUT_FILE} \ if grep -q 'CHECK-FIXES' "${INPUT_FILE}"; then
FileCheck -input-file="${TEMPORARY_FILE}" "${INPUT_FILE}" \
-check-prefix=CHECK-FIXES -strict-whitespace -check-prefix=CHECK-FIXES -strict-whitespace
fi
if grep -q CHECK-MESSAGES ${INPUT_FILE}; then if grep -q 'CHECK-MESSAGES' "${INPUT_FILE}"; then
FileCheck -input-file=${TEMPORARY_FILE}.msg ${INPUT_FILE} \ FileCheck -input-file="${TEMPORARY_FILE}.msg" "${INPUT_FILE}" \
-check-prefix=CHECK-MESSAGES -implicit-check-not="{{warning|error}}:" -check-prefix=CHECK-MESSAGES -implicit-check-not='{{warning|error}}:'
fi fi

test/clang-tidy/check_clang_tidy_fix.sh

  • This file was moved to test/clang-tidy/check_clang_tidy.sh.

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-build-explicit-make-pair %t // RUN: $(dirname %s)/check_clang_tidy.sh %s google-build-explicit-make-pair %t
// REQUIRES: shell // REQUIRES: shell
namespace std { namespace std {
template <class T1, class T2> template <class T1, class T2>
struct pair { struct pair {
pair(T1 x, T2 y) {} pair(T1 x, T2 y) {}
}; };
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

// RUN: clang-tidy %s -checks='-*,google-runtime-member-string-references' -- | FileCheck %s -implicit-check-not="{{warning|error}}:" // RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-member-string-references %t
// REQUIRES: shell
namespace std { namespace std {
template<typename T> template<typename T>
class basic_string {}; class basic_string {};
typedef basic_string<char> string; typedef basic_string<char> string;
} }
class string {}; class string {};
struct A { struct A {
const std::string &s; const std::string &s;
// CHECK: :[[@LINE-1]]:3: warning: const string& members are dangerous. It is much better to use alternatives, such as pointers or simple constants. // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: const string& members are dangerous. It is much better to use alternatives, such as pointers or simple constants. [google-runtime-member-string-references]
}; };
struct B { struct B {
std::string &s; std::string &s;
}; };
struct C { struct C {
const std::string s; const std::string s;
}; };
template <typename T> template <typename T>
struct D { struct D {
D(); D();
const T &s; const T &s;
const std::string &s2; const std::string &s2;
// CHECK: :[[@LINE-1]]:3: warning: const string& members are dangerous. It is much better to use alternatives, such as pointers or simple constants. // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: const string& members are dangerous.
}; };
D<std::string> d; D<std::string> d;
struct AA { struct AA {
const string &s; const string &s;
// CHECK: :[[@LINE-1]]:3: warning: const string& members are dangerous. It is much better to use alternatives, such as pointers or simple constants. // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: const string& members are dangerous.
}; };
struct BB { struct BB {
string &s; string &s;
}; };
struct CC { struct CC {
const string s; const string s;
}; };
D<string> dd; D<string> dd;

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-runtime-memset %t // RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-memset %t
// REQUIRES: shell // REQUIRES: shell
void *memset(void *, int, __SIZE_TYPE__); void *memset(void *, int, __SIZE_TYPE__);
namespace std { namespace std {
using ::memset; using ::memset;
} }
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

// RUN: clang-tidy %s -checks='-*,google-runtime-operator' -- | FileCheck %s -implicit-check-not="{{warning|error}}:" // RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-operator %t
// REQUIRES: shell
struct Foo { struct Foo {
void *operator&(); void *operator&();
// CHECK: :[[@LINE-1]]:3: warning: do not overload unary operator&, it is dangerous. // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not overload unary operator&, it is dangerous. [google-runtime-operator]
}; };
template <typename T> template <typename T>
struct TFoo { struct TFoo {
T *operator&(); T *operator&();
// CHECK: :[[@LINE-1]]:3: warning: do not overload unary operator&, it is dangerous. // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not overload unary operator&
}; };
TFoo<int> tfoo; TFoo<int> tfoo;
struct Bar; struct Bar;
void *operator&(Bar &b); void *operator&(Bar &b);
// CHECK: :[[@LINE-1]]:1: warning: do not overload unary operator&, it is dangerous. // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not overload unary operator&
// No warnings on binary operators.
struct Qux { struct Qux {
void *operator&(Qux &q); // no-warning void *operator&(Qux &q);
}; };
void *operator&(Qux &q, Qux &r); // no-warning void *operator&(Qux &q, Qux &r);

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-casting %t -- -x c // RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-casting %t -- -x c
// REQUIRES: shell // REQUIRES: shell
void f(const char *cpc) { void f(const char *cpc) {
const char *cpc2 = (const char*)cpc; const char *cpc2 = (const char*)cpc;
// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: Redundant cast to the same type. [google-readability-casting] // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: Redundant cast to the same type. [google-readability-casting]
// CHECK-FIXES: const char *cpc2 = cpc; // CHECK-FIXES: const char *cpc2 = cpc;
char *pc = (char*)cpc; char *pc = (char*)cpc;
} }

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-casting %t // RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-casting %t
// REQUIRES: shell // REQUIRES: shell
bool g() { return false; } bool g() { return false; }
enum Enum { Enum1 }; enum Enum { Enum1 };
struct X {}; struct X {};
struct Y : public X {}; struct Y : public X {};
▲ Show 20 Lines • Show All 117 Lines • Show Last 20 Lines

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-function %t // RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-function %t
// REQUIRES: shell // REQUIRES: shell
void Method(char *) { /* */ } void Method(char *) { /* */ }
// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: all parameters should be named in a function // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: all parameters should be named in a function
// CHECK-FIXES: void Method(char * /*unused*/) { /* */ } // CHECK-FIXES: void Method(char * /*unused*/) { /* */ }
void Method2(char *) {} void Method2(char *) {}
// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: all parameters should be named in a function // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: all parameters should be named in a function
// CHECK-FIXES: void Method2(char * /*unused*/) {} // CHECK-FIXES: void Method2(char * /*unused*/) {}
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-namespace-comments %t // RUN: $(dirname %s)/check_clang_tidy.sh %s google-readability-namespace-comments %t
// REQUIRES: shell // REQUIRES: shell
// CHECK-MESSAGES: :[[@LINE+2]]:11: warning: namespace not terminated with a closing comment [google-readability-namespace-comments] // CHECK-MESSAGES: :[[@LINE+2]]:11: warning: namespace not terminated with a closing comment [google-readability-namespace-comments]
// CHECK-MESSAGES: :[[@LINE+2]]:11: warning: namespace not terminated with a closing comment [google-readability-namespace-comments] // CHECK-MESSAGES: :[[@LINE+2]]:11: warning: namespace not terminated with a closing comment [google-readability-namespace-comments]
namespace n1 { namespace n1 {
namespace n2 { namespace n2 {
} }
} }
// CHECK-FIXES: } // namespace n2 // CHECK-FIXES: } // namespace n2
// CHECK-FIXES: } // namespace n1 // CHECK-FIXES: } // namespace n1
namespace short1 { namespace short2 { } } namespace short1 { namespace short2 { } }

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

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

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

// RUN: clang-tidy -checks=-*,google-runtime-int %s -- -x c++ 2>&1 | FileCheck %s -implicit-check-not='{{warning:|error:}}' // RUN: $(dirname %s)/check_clang_tidy.sh %s google-runtime-int %t
// REQUIRES: shell
long a(); long a();
// CHECK: [[@LINE-1]]:1: warning: consider replacing 'long' with 'int{{..}}' // CHECK-MESSAGES: [[@LINE-1]]:1: warning: consider replacing 'long' with 'int{{..}}'
typedef unsigned long long uint64; // NOLINT typedef unsigned long long uint64; // NOLINT
long b(long = 1); long b(long = 1);
// CHECK: [[@LINE-1]]:1: warning: consider replacing 'long' with 'int{{..}}' // CHECK-MESSAGES: [[@LINE-1]]:1: warning: consider replacing 'long' with 'int{{..}}'
// CHECK: [[@LINE-2]]:8: warning: consider replacing 'long' with 'int{{..}}' // CHECK-MESSAGES: [[@LINE-2]]:8: warning: consider replacing 'long' with 'int{{..}}'
template <typename T> template <typename T>
void tmpl() { void tmpl() {
T i; T i;
} }
short bar(const short, unsigned short) { short bar(const short, unsigned short) {
// CHECK: [[@LINE-1]]:1: warning: consider replacing 'short' with 'int16' // CHECK-MESSAGES: [[@LINE-1]]:1: warning: consider replacing 'short' with 'int16'
// CHECK: [[@LINE-2]]:17: warning: consider replacing 'short' with 'int16' // CHECK-MESSAGES: [[@LINE-2]]:17: warning: consider replacing 'short' with 'int16'
// CHECK: [[@LINE-3]]:24: warning: consider replacing 'unsigned short' with 'uint16' // CHECK-MESSAGES: [[@LINE-3]]:24: warning: consider replacing 'unsigned short' with 'uint16'
long double foo = 42; long double foo = 42;
uint64 qux = 42; uint64 qux = 42;
unsigned short port; unsigned short port;
const unsigned short bar = 0; const unsigned short bar = 0;
// CHECK: [[@LINE-1]]:9: warning: consider replacing 'unsigned short' with 'uint16' // CHECK-MESSAGES: [[@LINE-1]]:9: warning: consider replacing 'unsigned short' with 'uint16'
long long *baar; long long *baar;
// CHECK: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64' // CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64'
const unsigned short &bara = bar; const unsigned short &bara = bar;
// CHECK: [[@LINE-1]]:9: warning: consider replacing 'unsigned short' with 'uint16' // CHECK-MESSAGES: [[@LINE-1]]:9: warning: consider replacing 'unsigned short' with 'uint16'
long const long moo = 1; long const long moo = 1;
// CHECK: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64' // CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64'
long volatile long wat = 42; long volatile long wat = 42;
// CHECK: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64' // CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'long long' with 'int64'
unsigned long y; unsigned long y;
// CHECK: [[@LINE-1]]:3: warning: consider replacing 'unsigned long' with 'uint{{..}}' // CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'unsigned long' with 'uint{{..}}'
unsigned long long **const *tmp; unsigned long long **const *tmp;
// CHECK: [[@LINE-1]]:3: warning: consider replacing 'unsigned long long' with 'uint64' // CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'unsigned long long' with 'uint64'
unsigned long long **const *&z = tmp; unsigned long long **const *&z = tmp;
// CHECK: [[@LINE-1]]:3: warning: consider replacing 'unsigned long long' with 'uint64' // CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'unsigned long long' with 'uint64'
unsigned short porthole; unsigned short porthole;
// CHECK: [[@LINE-1]]:3: warning: consider replacing 'unsigned short' with 'uint16' // CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'unsigned short' with 'uint16'
uint64 cast = (short)42; uint64 cast = (short)42;
// CHECK: [[@LINE-1]]:18: warning: consider replacing 'short' with 'int16' // CHECK-MESSAGES: [[@LINE-1]]:18: warning: consider replacing 'short' with 'int16'
#define l long #define l long
l x; l x;
tmpl<short>(); tmpl<short>();
// CHECK: [[@LINE-1]]:8: warning: consider replacing 'short' with 'int16' // CHECK-MESSAGES: [[@LINE-1]]:8: warning: consider replacing 'short' with 'int16'
} }
void p(unsigned short port); void p(unsigned short port);
void qux() { void qux() {
short port; short port;
// CHECK: [[@LINE-1]]:3: warning: consider replacing 'short' with 'int16' // CHECK-MESSAGES: [[@LINE-1]]:3: warning: consider replacing 'short' with 'int16'
} }

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

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

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

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

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-bool-pointer-implicit-conversion %t // RUN: $(dirname %s)/check_clang_tidy.sh %s misc-bool-pointer-implicit-conversion %t
// REQUIRES: shell // REQUIRES: shell
bool *SomeFunction(); bool *SomeFunction();
void SomeOtherFunction(bool*); void SomeOtherFunction(bool*);
bool F(); bool F();
void G(bool); void G(bool);
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

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

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

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

// RUN: clang-tidy -checks='-*,misc-undelegated-constructor' %s -- -std=c++11 2>&1 | FileCheck %s -implicit-check-not='{{warning:|error:}}' // RUN: $(dirname %s)/check_clang_tidy.sh %s misc-undelegated-constructor %t
// REQUIRES: shell
struct Ctor; struct Ctor;
Ctor foo(); Ctor foo();
struct Ctor { struct Ctor {
Ctor(); Ctor();
Ctor(int); Ctor(int);
Ctor(int, int); Ctor(int, int);
Ctor(Ctor *i) { Ctor(Ctor *i) {
Ctor(); Ctor();
// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead [misc-undelegated-constructor]
Ctor(0); Ctor(0);
// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
Ctor(1, 2); Ctor(1, 2);
// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
foo(); foo();
} }
}; };
Ctor::Ctor() { Ctor::Ctor() {
Ctor(1); Ctor(1);
// CHECK: :[[@LINE-1]]:3: warning: did you intend to call a delegated constructor? A temporary object is created here instead // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: did you intend to call a delegated constructor?
} }
Ctor::Ctor(int i) : Ctor(i, 1) {} // properly delegated. Ctor::Ctor(int i) : Ctor(i, 1) {} // properly delegated.
struct Dtor { struct Dtor {
Dtor(); Dtor();
Dtor(int); Dtor(int);
Dtor(int, int); Dtor(int, int);
Dtor(Ctor *i) { Dtor(Ctor *i) {
Dtor(); Dtor();
// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
Dtor(0); Dtor(0);
// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
Dtor(1, 2); Dtor(1, 2);
// CHECK: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor? A temporary object is created here instead // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: did you intend to call a delegated constructor?
} }
~Dtor(); ~Dtor();
}; };
struct Base {}; struct Base {};
struct Derived : public Base { struct Derived : public Base {
Derived() { Base(); } Derived() { Base(); }
// CHECK: :[[@LINE-1]]:15: warning: did you intend to call a delegated constructor? A temporary object is created here instead // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: did you intend to call a delegated constructor?
}; };
template <typename T> template <typename T>
struct TDerived : public Base { struct TDerived : public Base {
TDerived() { Base(); } TDerived() { Base(); }
}; };
TDerived<int> t; TDerived<int> t;

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-unused-raii %t // RUN: $(dirname %s)/check_clang_tidy.sh %s misc-unused-raii %t
// REQUIRES: shell // REQUIRES: shell
struct Foo { struct Foo {
Foo(); Foo();
Foo(int); Foo(int);
Foo(int, int); Foo(int, int);
~Foo(); ~Foo();
}; };
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-use-override %t // RUN: $(dirname %s)/check_clang_tidy.sh %s misc-use-override %t
// REQUIRES: shell // REQUIRES: shell
#define ABSTRACT = 0 #define ABSTRACT = 0
#define OVERRIDE override #define OVERRIDE override
#define VIRTUAL virtual #define VIRTUAL virtual
#define NOT_VIRTUAL #define NOT_VIRTUAL
#define NOT_OVERRIDE #define NOT_OVERRIDE
▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines

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

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

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

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

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

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

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-braces-around-statements %t // RUN: $(dirname %s)/check_clang_tidy.sh %s readability-braces-around-statements %t
// REQUIRES: shell // REQUIRES: shell
void do_something(const char *) {} void do_something(const char *) {}
bool cond(const char *) { bool cond(const char *) {
return false; return false;
} }
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

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

// RUN: rm -rf %t // RUN: $(dirname %s)/check_clang_tidy.sh %s readability-function-size %t -config='{CheckOptions: [{key: readability-function-size.LineThreshold, value: 0}, {key: readability-function-size.StatementThreshold, value: 0}, {key: readability-function-size.BranchThreshold, value: 0}]}' -- -std=c++11
// RUN: mkdir -p %t // REQUIRES: shell
// RUN: sed 's#// *[A-Z-][A-Z-]*:.*#//#' %s > %t/t.cpp
// RUN: echo '{ Checks: "-*,readability-function-size", CheckOptions: [{key: readability-function-size.LineThreshold, value: 0}, {key: readability-function-size.StatementThreshold, value: 0}, {key: readability-function-size.BranchThreshold, value: 0}]}' > %t/.clang-tidy
// RUN: clang-tidy %t/t.cpp -- -std=c++11 2>&1 | FileCheck %s -implicit-check-not='{{warning:|error:|note:}}'
void foo1() { void foo1() {
} }
void foo2() {;} void foo2() {;}
// CHECK: warning: function 'foo2' exceeds recommended size/complexity thresholds // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'foo2' exceeds recommended size/complexity thresholds [readability-function-size]
// CHECK: note: 1 statements (threshold 0) // CHECK-MESSAGES: :[[@LINE-2]]:6: note: 1 statements (threshold 0)
void foo3() { void foo3() {
; ;
} }
// CHECK: warning: function 'foo3' exceeds recommended size/complexity thresholds // CHECK-MESSAGES: :[[@LINE-4]]:6: warning: function 'foo3' exceeds recommended size/complexity
// CHECK: note: 3 lines including whitespace and comments (threshold 0) // CHECK-MESSAGES: :[[@LINE-5]]:6: note: 3 lines including whitespace and comments (threshold 0)
// CHECK: note: 1 statements (threshold 0) // CHECK-MESSAGES: :[[@LINE-6]]:6: note: 1 statements (threshold 0)
void foo4(int i) { if (i) {} else; {} void foo4(int i) { if (i) {} else; {}
} }
// CHECK: warning: function 'foo4' exceeds recommended size/complexity thresholds // CHECK-MESSAGES: :[[@LINE-2]]:6: warning: function 'foo4' exceeds recommended size/complexity
// CHECK: note: 1 lines including whitespace and comments (threshold 0) // CHECK-MESSAGES: :[[@LINE-3]]:6: note: 1 lines including whitespace and comments (threshold 0)
// CHECK: note: 3 statements (threshold 0) // CHECK-MESSAGES: :[[@LINE-4]]:6: note: 3 statements (threshold 0)
// CHECK: note: 1 branches (threshold 0) // CHECK-MESSAGES: :[[@LINE-5]]:6: note: 1 branches (threshold 0)
void foo5(int i) {for(;i;)while(i) void foo5(int i) {for(;i;)while(i)
do;while(i); do;while(i);
} }
// CHECK: warning: function 'foo5' exceeds recommended size/complexity thresholds // CHECK-MESSAGES: :[[@LINE-3]]:6: warning: function 'foo5' exceeds recommended size/complexity
// CHECK: note: 2 lines including whitespace and comments (threshold 0) // CHECK-MESSAGES: :[[@LINE-4]]:6: note: 2 lines including whitespace and comments (threshold 0)
// CHECK: note: 7 statements (threshold 0) // CHECK-MESSAGES: :[[@LINE-5]]:6: note: 7 statements (threshold 0)
// CHECK: note: 3 branches (threshold 0) // CHECK-MESSAGES: :[[@LINE-6]]:6: note: 3 branches (threshold 0)
template <typename T> T foo6(T i) {return i; template <typename T> T foo6(T i) {return i;
} }
int x = foo6(0); int x = foo6(0);
// CHECK: warning: function 'foo6' exceeds recommended size/complexity thresholds // CHECK-MESSAGES: :[[@LINE-3]]:25: warning: function 'foo6' exceeds recommended size/complexity
// CHECK: note: 1 lines including whitespace and comments (threshold 0) // CHECK-MESSAGES: :[[@LINE-4]]:25: note: 1 lines including whitespace and comments (threshold 0)
// CHECK: note: 1 statements (threshold 0) // CHECK-MESSAGES: :[[@LINE-5]]:25: note: 1 statements (threshold 0)
void bar1() { [](){;;;;;;;;;;;if(1){}}(); void bar1() { [](){;;;;;;;;;;;if(1){}}();
} }
// CHECK: warning: function 'bar1' exceeds recommended size/complexity thresholds // CHECK-MESSAGES: :[[@LINE-4]]:6: warning: function 'bar1' exceeds recommended size/complexity
// CHECK: note: 3 lines including whitespace and comments (threshold 0) // CHECK-MESSAGES: :[[@LINE-5]]:6: note: 3 lines including whitespace and comments (threshold 0)
// CHECK: note: 14 statements (threshold 0) // CHECK-MESSAGES: :[[@LINE-6]]:6: note: 14 statements (threshold 0)
// CHECK: note: 1 branches (threshold 0) // CHECK-MESSAGES: :[[@LINE-7]]:6: note: 1 branches (threshold 0)
void bar2() { class A { void barx() {;;} }; } void bar2() { class A { void barx() {;;} }; }
// CHECK: warning: function 'bar2' exceeds recommended size/complexity thresholds // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'bar2' exceeds recommended size/complexity
// CHECK: note: 3 statements (threshold 0) // CHECK-MESSAGES: :[[@LINE-2]]:6: note: 3 statements (threshold 0)
// //
// CHECK: warning: function 'barx' exceeds recommended size/complexity thresholds // CHECK-MESSAGES: :[[@LINE-4]]:30: warning: function 'barx' exceeds recommended size/complexity
// CHECK: note: 2 statements (threshold 0) // CHECK-MESSAGES: :[[@LINE-5]]:30: note: 2 statements (threshold 0)

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

// RUN: $(dirname %s)/check_clang_tidy_fix.sh %s readability-redundant-smartptr-get %t // RUN: $(dirname %s)/check_clang_tidy.sh %s readability-redundant-smartptr-get %t
// REQUIRES: shell // REQUIRES: shell
#define NULL __null #define NULL __null
namespace std { namespace std {
template <typename T> template <typename T>
struct unique_ptr { struct unique_ptr {
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

test/clang-tidy/select-checks.cpp

// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp // RUN: clang-tidy %s -checks='-*,llvm-namespace-comment' -- 2>&1 | FileCheck -implicit-check-not='{{warning:|error:}}' %s
// RUN: clang-tidy %t.cpp -fix -checks='-*,llvm-*' -- // RUN: clang-tidy %s -checks='-*,an-unknown-check' -- 2>&1 | FileCheck -implicit-check-not='{{warning:|error:}}' -check-prefix=CHECK2 %s
// RUN: FileCheck -input-file=%t.cpp %s
// RUN: clang-tidy %s -checks='-*,an-unknown-check' -- 2>&1 | FileCheck -check-prefix=CHECK2 %s
// CHECK2: Error: no checks enabled. // CHECK2: Error: no checks enabled.
namespace i { namespace i {
} }
// CHECK: } // namespace i // CHECK: :[[@LINE-2]]:11: warning: namespace not terminated with a closing comment [llvm-namespace-comment]
class A { A(int i); }; // Not fixing this, because the check is in google-. // Expect no warnings from the google-explicit-constructor check:
// CHECK: class A { A(int i); }; class A { A(int i); };