diff --git a/clang-tools-extra/docs/ReleaseNotes.rst b/clang-tools-extra/docs/ReleaseNotes.rst --- a/clang-tools-extra/docs/ReleaseNotes.rst +++ b/clang-tools-extra/docs/ReleaseNotes.rst @@ -261,6 +261,11 @@ ` which failed to indicate the number of asterisks. +- Improved readability for hungarian notation in + :doc:`readability-identifier-naming + ` by changing the prefix + from `cust` to `my` in regression test. + - Fixed a false positive in :doc:`readability-implicit-bool-conversion ` check warning would be unnecessarily emitted for explicit cast using direct list initialization. diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/identifier-naming/hungarian-notation2/.clang-tidy b/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/identifier-naming/hungarian-notation2/.clang-tidy --- a/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/identifier-naming/hungarian-notation2/.clang-tidy +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/Inputs/identifier-naming/hungarian-notation2/.clang-tidy @@ -115,162 +115,162 @@ - key: readability-identifier-naming.HungarianNotation.General.TreatStructAsClass value: true - key: readability-identifier-naming.HungarianNotation.DerivedType.Array - value: custa + value: mya - key: readability-identifier-naming.HungarianNotation.DerivedType.Pointer - value: custp + value: myp - key: readability-identifier-naming.HungarianNotation.DerivedType.FunctionPointer - value: custfn + value: myfn - key: readability-identifier-naming.HungarianNotation.CString.CharPointer - value: custsz + value: mysz - key: readability-identifier-naming.HungarianNotation.CString.CharArray - value: custsz + value: mysz - key: readability-identifier-naming.HungarianNotation.CString.WideCharPointer - value: custwsz + value: mywsz - key: readability-identifier-naming.HungarianNotation.CString.WideCharArray - value: custwsz + value: mywsz - key: readability-identifier-naming.HungarianNotation.PrimitiveType.int8_t - value: custi8 + value: myi8 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.int16_t - value: custi16 + value: myi16 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.int32_t - value: custi32 + value: myi32 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.int64_t - value: custi64 + value: myi64 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint8_t - value: custu8 + value: myu8 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint16_t - value: custu16 + value: myu16 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint32_t - value: custu32 + value: myu32 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.uint64_t - value: custu64 + value: myu64 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.char8_t - value: custc8 + value: myc8 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.char16_t - value: custc16 + value: myc16 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.char32_t - value: custc32 + value: myc32 - key: readability-identifier-naming.HungarianNotation.PrimitiveType.float - value: custf + value: myf - key: readability-identifier-naming.HungarianNotation.PrimitiveType.double - value: custd + value: myd - key: readability-identifier-naming.HungarianNotation.PrimitiveType.char - value: custc + value: myc - key: readability-identifier-naming.HungarianNotation.PrimitiveType.bool - value: custb + value: myb - key: readability-identifier-naming.HungarianNotation.PrimitiveType._Bool - value: custb + value: myb - key: readability-identifier-naming.HungarianNotation.PrimitiveType.int - value: custi + value: myi - key: readability-identifier-naming.HungarianNotation.PrimitiveType.size_t - value: custn + value: myn - key: readability-identifier-naming.HungarianNotation.PrimitiveType.wchar_t - value: custwc + value: mywc - key: readability-identifier-naming.HungarianNotation.PrimitiveType.short-int - value: custsi + value: mysi - key: readability-identifier-naming.HungarianNotation.PrimitiveType.short - value: custs + value: mys - key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-int - value: custsi + value: mysi - key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-short - value: custss + value: myss - key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-short-int - value: custssi + value: myssi - key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-long-int - value: custslli + value: myslli - key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-long - value: custsll + value: mysll - key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-int - value: custsli + value: mysli - key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long - value: custsl + value: mysl - key: readability-identifier-naming.HungarianNotation.PrimitiveType.signed - value: custs + value: mys - key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-long-int - value: custulli + value: myulli - key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-long - value: custull + value: myull - key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-int - value: custuli + value: myuli - key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long - value: custul + value: myul - key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-short-int - value: custusi + value: myusi - key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-short - value: custus + value: myus - key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-int - value: custui + value: myui - key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-char - value: custuc + value: myuc - key: readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned - value: custu + value: myu - key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-long-int - value: custlli + value: mylli - key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-double - value: custld + value: myld - key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-long - value: custll + value: myll - key: readability-identifier-naming.HungarianNotation.PrimitiveType.long-int - value: custli + value: myli - key: readability-identifier-naming.HungarianNotation.PrimitiveType.long - value: custl + value: myl - key: readability-identifier-naming.HungarianNotation.PrimitiveType.ptrdiff_t - value: custp + value: myp - key: readability-identifier-naming.HungarianNotation.PrimitiveType.void - value: custv + value: myv - key: readability-identifier-naming.HungarianNotation.UserDefinedType.BOOL - value: custb + value: myb - key: readability-identifier-naming.HungarianNotation.UserDefinedType.BOOLEAN - value: custb + value: myb - key: readability-identifier-naming.HungarianNotation.UserDefinedType.BYTE - value: custby + value: myby - key: readability-identifier-naming.HungarianNotation.UserDefinedType.CHAR - value: custc + value: myc - key: readability-identifier-naming.HungarianNotation.UserDefinedType.UCHAR - value: custuc + value: myuc - key: readability-identifier-naming.HungarianNotation.UserDefinedType.SHORT - value: custs + value: mys - key: readability-identifier-naming.HungarianNotation.UserDefinedType.USHORT - value: custus + value: myus - key: readability-identifier-naming.HungarianNotation.UserDefinedType.WORD - value: custw + value: myw - key: readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD - value: custdw + value: mydw - key: readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD32 - value: custdw32 + value: mydw32 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD64 - value: custdw64 + value: mydw64 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.LONG - value: custl + value: myl - key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG - value: custul + value: myul - key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG32 - value: custul32 + value: myul32 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG64 - value: custul64 + value: myul64 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.ULONGLONG - value: custull + value: myull - key: readability-identifier-naming.HungarianNotation.UserDefinedType.HANDLE - value: custh + value: myh - key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT - value: custi + value: myi - key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT8 - value: custi8 + value: myi8 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT16 - value: custi16 + value: myi16 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT32 - value: custi32 + value: myi32 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.INT64 - value: custi64 + value: myi64 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT - value: custui + value: myui - key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT8 - value: custu8 + value: myu8 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT16 - value: custu16 + value: myu16 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT32 - value: custu32 + value: myu32 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.UINT64 - value: custu64 + value: myu64 - key: readability-identifier-naming.HungarianNotation.UserDefinedType.PVOID - value: custp + value: myp diff --git a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-cfgfile.cpp b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-cfgfile.cpp --- a/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-cfgfile.cpp +++ b/clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming-hungarian-notation-cfgfile.cpp @@ -11,159 +11,159 @@ public: static int ClassMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for class member 'ClassMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} static int custiClassMemberCase; + // CHECK-FIXES: {{^}} static int myiClassMemberCase; char const ConstantMemberCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for constant member 'ConstantMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char const custcConstantMemberCase = 0; + // CHECK-FIXES: {{^}} char const mycConstantMemberCase = 0; void MyFunc1(const int ConstantParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: invalid case style for constant parameter 'ConstantParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void MyFunc1(const int custiConstantParameterCase); + // CHECK-FIXES: {{^}} void MyFunc1(const int myiConstantParameterCase); void MyFunc2(const int* ConstantPointerParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: invalid case style for pointer parameter 'ConstantPointerParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void MyFunc2(const int* custpcustiConstantPointerParameterCase); + // CHECK-FIXES: {{^}} void MyFunc2(const int* mypmyiConstantPointerParameterCase); static constexpr int ConstexprVariableCase = 123; // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for constexpr variable 'ConstexprVariableCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} static constexpr int custiConstexprVariableCase = 123; + // CHECK-FIXES: {{^}} static constexpr int myiConstexprVariableCase = 123; }; const int GlobalConstantCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global constant 'GlobalConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int custiGlobalConstantCase = 0; +// CHECK-FIXES: {{^}}const int myiGlobalConstantCase = 0; const int* GlobalConstantPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global pointer 'GlobalConstantPointerCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int* custpcustiGlobalConstantPointerCase = nullptr; +// CHECK-FIXES: {{^}}const int* mypmyiGlobalConstantPointerCase = nullptr; int* GlobalPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'GlobalPointerCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int* custpcustiGlobalPointerCase = nullptr; +// CHECK-FIXES: {{^}}int* mypmyiGlobalPointerCase = nullptr; int GlobalVariableCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalVariableCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiGlobalVariableCase = 0; +// CHECK-FIXES: {{^}}int myiGlobalVariableCase = 0; void Func1(){ int const LocalConstantCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for local constant 'LocalConstantCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int const custiLocalConstantCase = 3; + // CHECK-FIXES: {{^}} int const myiLocalConstantCase = 3; unsigned const ConstantCase = 1; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for local constant 'ConstantCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} unsigned const custuConstantCase = 1; + // CHECK-FIXES: {{^}} unsigned const myuConstantCase = 1; int* const LocalConstantPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for local constant pointer 'LocalConstantPointerCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int* const custpcustiLocalConstantPointerCase = nullptr; + // CHECK-FIXES: {{^}} int* const mypmyiLocalConstantPointerCase = nullptr; int *LocalPointerCase = nullptr; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for local pointer 'LocalPointerCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int *custpcustiLocalPointerCase = nullptr; + // CHECK-FIXES: {{^}} int *mypmyiLocalPointerCase = nullptr; int LocalVariableCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for local variable 'LocalVariableCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} int custiLocalVariableCase = 0; + // CHECK-FIXES: {{^}} int myiLocalVariableCase = 0; } class CMyClass2 { char MemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'MemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char custcMemberCase; + // CHECK-FIXES: {{^}} char mycMemberCase; void Func1(int ParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'ParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void Func1(int custiParameterCase); + // CHECK-FIXES: {{^}} void Func1(int myiParameterCase); void Func2(const int ParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for constant parameter 'ParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void Func2(const int custiParameterCase); + // CHECK-FIXES: {{^}} void Func2(const int myiParameterCase); void Func3(const int *PointerParameterCase); // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: invalid case style for pointer parameter 'PointerParameterCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} void Func3(const int *custpcustiPointerParameterCase); + // CHECK-FIXES: {{^}} void Func3(const int *mypmyiPointerParameterCase); }; class CMyClass3 { private: char PrivateMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'PrivateMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char custcPrivateMemberCase; + // CHECK-FIXES: {{^}} char mycPrivateMemberCase; protected: char ProtectedMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for protected member 'ProtectedMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char custcProtectedMemberCase; + // CHECK-FIXES: {{^}} char mycProtectedMemberCase; public: char PublicMemberCase; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for public member 'PublicMemberCase' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char custcPublicMemberCase; + // CHECK-FIXES: {{^}} char mycPublicMemberCase; }; static const int StaticConstantCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global constant 'StaticConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static const int custiStaticConstantCase = 3; +// CHECK-FIXES: {{^}}static const int myiStaticConstantCase = 3; static int StaticVariableCase = 3; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'StaticVariableCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static int custiStaticVariableCase = 3; +// CHECK-FIXES: {{^}}static int myiStaticVariableCase = 3; struct CMyStruct { int StructCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for public member 'StructCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}struct CMyStruct { int custiStructCase; }; +// CHECK-FIXES: {{^}}struct CMyStruct { int myiStructCase; }; -union MyUnion { int UnionCase; long custlUnionCase; }; +union MyUnion { int UnionCase; long mylUnionCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for public member 'UnionCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}union MyUnion { int custiUnionCase; long custlUnionCase; }; +// CHECK-FIXES: {{^}}union MyUnion { int myiUnionCase; long mylUnionCase; }; //===----------------------------------------------------------------------===// // C string //===----------------------------------------------------------------------===// const char *NamePtr = "Name"; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global pointer 'NamePtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char *custszNamePtr = "Name"; +// CHECK-FIXES: {{^}}const char *myszNamePtr = "Name"; const char NameArray[] = "Name"; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global constant 'NameArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char custszNameArray[] = "Name"; +// CHECK-FIXES: {{^}}const char myszNameArray[] = "Name"; const char *NamePtrArray[] = {"AA", "BB"}; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'NamePtrArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const char *custpcustszNamePtrArray[] = {"AA", "BB"}; +// CHECK-FIXES: {{^}}const char *mypmyszNamePtrArray[] = {"AA", "BB"}; const wchar_t *WideNamePtr = L"Name"; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'WideNamePtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t *custwszWideNamePtr = L"Name"; +// CHECK-FIXES: {{^}}const wchar_t *mywszWideNamePtr = L"Name"; const wchar_t WideNameArray[] = L"Name"; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global constant 'WideNameArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t custwszWideNameArray[] = L"Name"; +// CHECK-FIXES: {{^}}const wchar_t mywszWideNameArray[] = L"Name"; const wchar_t *WideNamePtrArray[] = {L"AA", L"BB"}; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'WideNamePtrArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const wchar_t *custpcustwszWideNamePtrArray[] = {L"AA", L"BB"}; +// CHECK-FIXES: {{^}}const wchar_t *mypmywszWideNamePtrArray[] = {L"AA", L"BB"}; class CMyClass4 { private: char *Name = "Text"; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for private member 'Name' [readability-identifier-naming] - // CHECK-FIXES: {{^}} char *custszName = "Text"; + // CHECK-FIXES: {{^}} char *myszName = "Text"; const char *ConstName = "Text"; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for private member 'ConstName' [readability-identifier-naming] - // CHECK-FIXES: {{^}} const char *custszConstName = "Text"; + // CHECK-FIXES: {{^}} const char *myszConstName = "Text"; public: - const char* DuplicateString(const char* Input, size_t custnRequiredSize); + const char* DuplicateString(const char* Input, size_t mynRequiredSize); // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: invalid case style for pointer parameter 'Input' [readability-identifier-naming] - // CHECK-FIXES: {{^}} const char* DuplicateString(const char* custszInput, size_t custnRequiredSize); + // CHECK-FIXES: {{^}} const char* DuplicateString(const char* myszInput, size_t mynRequiredSize); - size_t UpdateText(const char* Buffer, size_t custnBufferSize); + size_t UpdateText(const char* Buffer, size_t mynBufferSize); // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: invalid case style for pointer parameter 'Buffer' [readability-identifier-naming] - // CHECK-FIXES: {{^}} size_t UpdateText(const char* custszBuffer, size_t custnBufferSize); + // CHECK-FIXES: {{^}} size_t UpdateText(const char* myszBuffer, size_t mynBufferSize); }; @@ -172,123 +172,123 @@ //===----------------------------------------------------------------------===// DWORD MsDword = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsDword' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD custdwMsDword = 0; +// CHECK-FIXES: {{^}}DWORD mydwMsDword = 0; BYTE MsByte = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsByte' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BYTE custbyMsByte = 0; +// CHECK-FIXES: {{^}}BYTE mybyMsByte = 0; WORD MsWord = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsWord' [readability-identifier-naming] -// CHECK-FIXES: {{^}}WORD custwMsWord = 0; +// CHECK-FIXES: {{^}}WORD mywMsWord = 0; BOOL MsBool = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsBool' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BOOL custbMsBool = 0; +// CHECK-FIXES: {{^}}BOOL mybMsBool = 0; BOOLEAN MsBoolean = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsBoolean' [readability-identifier-naming] -// CHECK-FIXES: {{^}}BOOLEAN custbMsBoolean = 0; +// CHECK-FIXES: {{^}}BOOLEAN mybMsBoolean = 0; CHAR MsValueChar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}CHAR custcMsValueChar = 0; +// CHECK-FIXES: {{^}}CHAR mycMsValueChar = 0; UCHAR MsValueUchar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUchar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UCHAR custucMsValueUchar = 0; +// CHECK-FIXES: {{^}}UCHAR myucMsValueUchar = 0; SHORT MsValueShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}SHORT custsMsValueShort = 0; +// CHECK-FIXES: {{^}}SHORT mysMsValueShort = 0; USHORT MsValueUshort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUshort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}USHORT custusMsValueUshort = 0; +// CHECK-FIXES: {{^}}USHORT myusMsValueUshort = 0; WORD MsValueWord = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueWord' [readability-identifier-naming] -// CHECK-FIXES: {{^}}WORD custwMsValueWord = 0; +// CHECK-FIXES: {{^}}WORD mywMsValueWord = 0; DWORD MsValueDword = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueDword' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD custdwMsValueDword = 0; +// CHECK-FIXES: {{^}}DWORD mydwMsValueDword = 0; DWORD32 MsValueDword32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD32 custdw32MsValueDword32 = 0; +// CHECK-FIXES: {{^}}DWORD32 mydw32MsValueDword32 = 0; DWORD64 MsValueDword64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}DWORD64 custdw64MsValueDword64 = 0; +// CHECK-FIXES: {{^}}DWORD64 mydw64MsValueDword64 = 0; LONG MsValueLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}LONG custlMsValueLong = 0; +// CHECK-FIXES: {{^}}LONG mylMsValueLong = 0; ULONG MsValueUlong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUlong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG custulMsValueUlong = 0; +// CHECK-FIXES: {{^}}ULONG myulMsValueUlong = 0; ULONG32 MsValueUlong32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG32 custul32MsValueUlong32 = 0; +// CHECK-FIXES: {{^}}ULONG32 myul32MsValueUlong32 = 0; ULONG64 MsValueUlong64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONG64 custul64MsValueUlong64 = 0; +// CHECK-FIXES: {{^}}ULONG64 myul64MsValueUlong64 = 0; ULONGLONG MsValueUlongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'MsValueUlongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ULONGLONG custullMsValueUlongLong = 0; +// CHECK-FIXES: {{^}}ULONGLONG myullMsValueUlongLong = 0; HANDLE MsValueHandle = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'MsValueHandle' [readability-identifier-naming] -// CHECK-FIXES: {{^}}HANDLE custhMsValueHandle = 0; +// CHECK-FIXES: {{^}}HANDLE myhMsValueHandle = 0; INT MsValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'MsValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT custiMsValueInt = 0; +// CHECK-FIXES: {{^}}INT myiMsValueInt = 0; INT8 MsValueInt8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueInt8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT8 custi8MsValueInt8 = 0; +// CHECK-FIXES: {{^}}INT8 myi8MsValueInt8 = 0; INT16 MsValueInt16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT16 custi16MsValueInt16 = 0; +// CHECK-FIXES: {{^}}INT16 myi16MsValueInt16 = 0; INT32 MsValueInt32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT32 custi32MsValueInt32 = 0; +// CHECK-FIXES: {{^}}INT32 myi32MsValueInt32 = 0; INT64 MsValueINt64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueINt64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}INT64 custi64MsValueINt64 = 0; +// CHECK-FIXES: {{^}}INT64 myi64MsValueINt64 = 0; UINT MsValueUint = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueUint' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT custuiMsValueUint = 0; +// CHECK-FIXES: {{^}}UINT myuiMsValueUint = 0; UINT8 MsValueUint8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUint8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT8 custu8MsValueUint8 = 0; +// CHECK-FIXES: {{^}}UINT8 myu8MsValueUint8 = 0; UINT16 MsValueUint16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT16 custu16MsValueUint16 = 0; +// CHECK-FIXES: {{^}}UINT16 myu16MsValueUint16 = 0; UINT32 MsValueUint32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT32 custu32MsValueUint32 = 0; +// CHECK-FIXES: {{^}}UINT32 myu32MsValueUint32 = 0; UINT64 MsValueUint64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}UINT64 custu64MsValueUint64 = 0; +// CHECK-FIXES: {{^}}UINT64 myu64MsValueUint64 = 0; PVOID MsValuePvoid = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'MsValuePvoid' [readability-identifier-naming] -// CHECK-FIXES: {{^}}PVOID custpMsValuePvoid = NULL; +// CHECK-FIXES: {{^}}PVOID mypMsValuePvoid = NULL; //===----------------------------------------------------------------------===// @@ -296,19 +296,19 @@ //===----------------------------------------------------------------------===// unsigned GlobalUnsignedArray[] = {1, 2, 3}; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'GlobalUnsignedArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned custaGlobalUnsignedArray[] = {1, 2, 3}; +// CHECK-FIXES: {{^}}unsigned myaGlobalUnsignedArray[] = {1, 2, 3}; int GlobalIntArray[] = {1, 2, 3}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalIntArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custaGlobalIntArray[] = {1, 2, 3}; +// CHECK-FIXES: {{^}}int myaGlobalIntArray[] = {1, 2, 3}; int DataInt[1] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custaDataInt[1] = {0}; +// CHECK-FIXES: {{^}}int myaDataInt[1] = {0}; int DataArray[2] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'DataArray' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custaDataArray[2] = {0}; +// CHECK-FIXES: {{^}}int myaDataArray[2] = {0}; //===----------------------------------------------------------------------===// @@ -316,74 +316,74 @@ //===----------------------------------------------------------------------===// int *DataIntPtr[1] = {0}; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'DataIntPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int *custpcustaDataIntPtr[1] = {0}; +// CHECK-FIXES: {{^}}int *mypmyaDataIntPtr[1] = {0}; void *BufferPtr1; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'BufferPtr1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void *custpcustvBufferPtr1; +// CHECK-FIXES: {{^}}void *mypmyvBufferPtr1; void **BufferPtr2; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'BufferPtr2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void **custpcustpcustvBufferPtr2; +// CHECK-FIXES: {{^}}void **mypmypmyvBufferPtr2; -void **custpBufferPtr3; -// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'custpBufferPtr3' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void **custpcustpcustvBufferPtr3; +void **mypBufferPtr3; +// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'mypBufferPtr3' [readability-identifier-naming] +// CHECK-FIXES: {{^}}void **mypmypmyvBufferPtr3; -int *custpBufferPtr4; -// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'custpBufferPtr4' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int *custpcustiBufferPtr4; +int *mypBufferPtr4; +// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'mypBufferPtr4' [readability-identifier-naming] +// CHECK-FIXES: {{^}}int *mypmyiBufferPtr4; typedef void (*FUNC_PTR_HELLO)(); FUNC_PTR_HELLO Hello = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'Hello' [readability-identifier-naming] -// CHECK-FIXES: {{^}}FUNC_PTR_HELLO custfnHello = NULL; +// CHECK-FIXES: {{^}}FUNC_PTR_HELLO myfnHello = NULL; void *ValueVoidPtr = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'ValueVoidPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void *custpcustvValueVoidPtr = NULL; +// CHECK-FIXES: {{^}}void *mypmyvValueVoidPtr = NULL; ptrdiff_t PtrDiff = NULL; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'PtrDiff' [readability-identifier-naming] -// CHECK-FIXES: {{^}}ptrdiff_t custpPtrDiff = NULL; +// CHECK-FIXES: {{^}}ptrdiff_t mypPtrDiff = NULL; int8_t *ValueI8Ptr; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global pointer 'ValueI8Ptr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int8_t *custpcusti8ValueI8Ptr; +// CHECK-FIXES: {{^}}int8_t *mypmyi8ValueI8Ptr; uint8_t *ValueU8Ptr; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global pointer 'ValueU8Ptr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint8_t *custpcustu8ValueU8Ptr; +// CHECK-FIXES: {{^}}uint8_t *mypmyu8ValueU8Ptr; unsigned char *ValueUcPtr; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global pointer 'ValueUcPtr' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char *custpcustucValueUcPtr; +// CHECK-FIXES: {{^}}unsigned char *mypmyucValueUcPtr; unsigned char **ValueUcPtr2; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for global pointer 'ValueUcPtr2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char **custpcustpcustucValueUcPtr2; +// CHECK-FIXES: {{^}}unsigned char **mypmypmyucValueUcPtr2; void MyFunc2(void* Val){} // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for pointer parameter 'Val' [readability-identifier-naming] -// CHECK-FIXES: {{^}}void MyFunc2(void* custpcustvVal){} +// CHECK-FIXES: {{^}}void MyFunc2(void* mypmyvVal){} //===----------------------------------------------------------------------===// // Reference //===----------------------------------------------------------------------===// -int custiValueIndex = 1; -int &RefValueIndex = custiValueIndex; +int myiValueIndex = 1; +int &RefValueIndex = myiValueIndex; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'RefValueIndex' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int &custiRefValueIndex = custiValueIndex; +// CHECK-FIXES: {{^}}int &myiRefValueIndex = myiValueIndex; -const int &ConstRefValue = custiValueIndex; +const int &ConstRefValue = myiValueIndex; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ConstRefValue' [readability-identifier-naming] -// CHECK-FIXES: {{^}}const int &custiConstRefValue = custiValueIndex; +// CHECK-FIXES: {{^}}const int &myiConstRefValue = myiValueIndex; -long long custllValueLongLong = 2; -long long &RefValueLongLong = custllValueLongLong; +long long myllValueLongLong = 2; +long long &RefValueLongLong = myllValueLongLong; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'RefValueLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long &custllRefValueLongLong = custllValueLongLong; +// CHECK-FIXES: {{^}}long long &myllRefValueLongLong = myllValueLongLong; //===----------------------------------------------------------------------===// @@ -391,151 +391,151 @@ //===----------------------------------------------------------------------===// int8_t ValueI8; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueI8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int8_t custi8ValueI8; +// CHECK-FIXES: {{^}}int8_t myi8ValueI8; int16_t ValueI16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int16_t custi16ValueI16 = 0; +// CHECK-FIXES: {{^}}int16_t myi16ValueI16 = 0; int32_t ValueI32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int32_t custi32ValueI32 = 0; +// CHECK-FIXES: {{^}}int32_t myi32ValueI32 = 0; int64_t ValueI64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int64_t custi64ValueI64 = 0; +// CHECK-FIXES: {{^}}int64_t myi64ValueI64 = 0; uint8_t ValueU8 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueU8' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint8_t custu8ValueU8 = 0; +// CHECK-FIXES: {{^}}uint8_t myu8ValueU8 = 0; uint16_t ValueU16 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU16' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint16_t custu16ValueU16 = 0; +// CHECK-FIXES: {{^}}uint16_t myu16ValueU16 = 0; uint32_t ValueU32 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU32' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint32_t custu32ValueU32 = 0; +// CHECK-FIXES: {{^}}uint32_t myu32ValueU32 = 0; uint64_t ValueU64 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueU64' [readability-identifier-naming] -// CHECK-FIXES: {{^}}uint64_t custu64ValueU64 = 0; +// CHECK-FIXES: {{^}}uint64_t myu64ValueU64 = 0; float ValueFloat = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueFloat' [readability-identifier-naming] -// CHECK-FIXES: {{^}}float custfValueFloat = 0; +// CHECK-FIXES: {{^}}float myfValueFloat = 0; double ValueDouble = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueDouble' [readability-identifier-naming] -// CHECK-FIXES: {{^}}double custdValueDouble = 0; +// CHECK-FIXES: {{^}}double mydValueDouble = 0; char ValueChar = 'c'; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}char custcValueChar = 'c'; +// CHECK-FIXES: {{^}}char mycValueChar = 'c'; bool ValueBool = true; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueBool' [readability-identifier-naming] -// CHECK-FIXES: {{^}}bool custbValueBool = true; +// CHECK-FIXES: {{^}}bool mybValueBool = true; int ValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'ValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiValueInt = 0; +// CHECK-FIXES: {{^}}int myiValueInt = 0; size_t ValueSize = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSize' [readability-identifier-naming] -// CHECK-FIXES: {{^}}size_t custnValueSize = 0; +// CHECK-FIXES: {{^}}size_t mynValueSize = 0; wchar_t ValueWchar = 'w'; // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueWchar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}wchar_t custwcValueWchar = 'w'; +// CHECK-FIXES: {{^}}wchar_t mywcValueWchar = 'w'; short ValueShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}short custsValueShort = 0; +// CHECK-FIXES: {{^}}short mysValueShort = 0; unsigned ValueUnsigned = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueUnsigned' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned custuValueUnsigned = 0; +// CHECK-FIXES: {{^}}unsigned myuValueUnsigned = 0; signed ValueSigned = 0; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSigned' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed custsValueSigned = 0; +// CHECK-FIXES: {{^}}signed mysValueSigned = 0; long ValueLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long custlValueLong = 0; +// CHECK-FIXES: {{^}}long mylValueLong = 0; long long ValueLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'ValueLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long custllValueLongLong = 0; +// CHECK-FIXES: {{^}}long long myllValueLongLong = 0; long long int ValueLongLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueLongLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long long int custlliValueLongLongInt = 0; +// CHECK-FIXES: {{^}}long long int mylliValueLongLongInt = 0; long double ValueLongDouble = 0; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueLongDouble' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long double custldValueLongDouble = 0; +// CHECK-FIXES: {{^}}long double myldValueLongDouble = 0; signed int ValueSignedInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ValueSignedInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed int custsiValueSignedInt = 0; +// CHECK-FIXES: {{^}}signed int mysiValueSignedInt = 0; signed short ValueSignedShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueSignedShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed short custssValueSignedShort = 0; +// CHECK-FIXES: {{^}}signed short myssValueSignedShort = 0; signed short int ValueSignedShortInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedShortInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed short int custssiValueSignedShortInt = 0; +// CHECK-FIXES: {{^}}signed short int myssiValueSignedShortInt = 0; signed long long ValueSignedLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ValueSignedLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long long custsllValueSignedLongLong = 0; +// CHECK-FIXES: {{^}}signed long long mysllValueSignedLongLong = 0; signed long int ValueSignedLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for global variable 'ValueSignedLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long int custsliValueSignedLongInt = 0; +// CHECK-FIXES: {{^}}signed long int mysliValueSignedLongInt = 0; signed long ValueSignedLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global variable 'ValueSignedLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}signed long custslValueSignedLong = 0; +// CHECK-FIXES: {{^}}signed long myslValueSignedLong = 0; unsigned long long int ValueUnsignedLongLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: invalid case style for global variable 'ValueUnsignedLongLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long long int custulliValueUnsignedLongLongInt = 0; +// CHECK-FIXES: {{^}}unsigned long long int myulliValueUnsignedLongLongInt = 0; unsigned long long ValueUnsignedLongLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedLongLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long long custullValueUnsignedLongLong = 0; +// CHECK-FIXES: {{^}}unsigned long long myullValueUnsignedLongLong = 0; unsigned long int ValueUnsignedLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for global variable 'ValueUnsignedLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long int custuliValueUnsignedLongInt = 0; +// CHECK-FIXES: {{^}}unsigned long int myuliValueUnsignedLongInt = 0; unsigned long ValueUnsignedLong = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueUnsignedLong' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned long custulValueUnsignedLong = 0; +// CHECK-FIXES: {{^}}unsigned long myulValueUnsignedLong = 0; unsigned short int ValueUnsignedShortInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global variable 'ValueUnsignedShortInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned short int custusiValueUnsignedShortInt = 0; +// CHECK-FIXES: {{^}}unsigned short int myusiValueUnsignedShortInt = 0; unsigned short ValueUnsignedShort = 0; // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global variable 'ValueUnsignedShort' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned short custusValueUnsignedShort = 0; +// CHECK-FIXES: {{^}}unsigned short myusValueUnsignedShort = 0; unsigned int ValueUnsignedInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'ValueUnsignedInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned int custuiValueUnsignedInt = 0; +// CHECK-FIXES: {{^}}unsigned int myuiValueUnsignedInt = 0; unsigned char ValueUnsignedChar = 0; // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for global variable 'ValueUnsignedChar' [readability-identifier-naming] -// CHECK-FIXES: {{^}}unsigned char custucValueUnsignedChar = 0; +// CHECK-FIXES: {{^}}unsigned char myucValueUnsignedChar = 0; long int ValueLongInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueLongInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}long int custliValueLongInt = 0; +// CHECK-FIXES: {{^}}long int myliValueLongInt = 0; //===----------------------------------------------------------------------===// @@ -543,33 +543,33 @@ //===----------------------------------------------------------------------===// volatile int VolatileInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'VolatileInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}volatile int custiVolatileInt = 0; +// CHECK-FIXES: {{^}}volatile int myiVolatileInt = 0; thread_local int ThreadLocalValueInt = 0; // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for global variable 'ThreadLocalValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}thread_local int custiThreadLocalValueInt = 0; +// CHECK-FIXES: {{^}}thread_local int myiThreadLocalValueInt = 0; extern int ExternValueInt; // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ExternValueInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}extern int custiExternValueInt; +// CHECK-FIXES: {{^}}extern int myiExternValueInt; struct CDataBuffer { mutable size_t Size; }; // CHECK-MESSAGES: :[[@LINE-2]]:20: warning: invalid case style for public member 'Size' [readability-identifier-naming] -// CHECK-FIXES: {{^}} mutable size_t custnSize; +// CHECK-FIXES: {{^}} mutable size_t mynSize; static constexpr int const &ConstExprInt = 42; // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: invalid case style for constexpr variable 'ConstExprInt' [readability-identifier-naming] -// CHECK-FIXES: {{^}}static constexpr int const &custiConstExprInt = 42; +// CHECK-FIXES: {{^}}static constexpr int const &myiConstExprInt = 42; //===----------------------------------------------------------------------===// // Redefined types //===----------------------------------------------------------------------===// typedef int INDEX; -INDEX custiIndex = 0; -// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'custiIndex' [readability-identifier-naming] +INDEX myiIndex = 0; +// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'myiIndex' [readability-identifier-naming] // CHECK-FIXES: {{^}}INDEX Index = 0; @@ -588,9 +588,9 @@ // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'AbstractClassCase1' [readability-identifier-naming] // CHECK-FIXES: {{^}}class IAbstractClassCase1 { virtual int Func1() = 0; int Func2(); }; -class ClassConstantCase { public: static const int custiConstantCase; }; +class ClassConstantCase { public: static const int myiConstantCase; }; // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'ClassConstantCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}class CClassConstantCase { public: static const int custiConstantCase; }; +// CHECK-FIXES: {{^}}class CClassConstantCase { public: static const int myiConstantCase; }; struct StructCase { int Func(); }; // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for class 'StructCase' [readability-identifier-naming] @@ -601,63 +601,63 @@ //===----------------------------------------------------------------------===// int lower_case = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiLowerCase = 0; +// CHECK-FIXES: {{^}}int myiLowerCase = 0; int lower_case1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiLowerCase1 = 0; +// CHECK-FIXES: {{^}}int myiLowerCase1 = 0; int lower_case_2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case_2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiLowerCase2 = 0; +// CHECK-FIXES: {{^}}int myiLowerCase2 = 0; int UPPER_CASE = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiUpperCase = 0; +// CHECK-FIXES: {{^}}int myiUpperCase = 0; int UPPER_CASE_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'UPPER_CASE_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiUpperCase1 = 0; +// CHECK-FIXES: {{^}}int myiUpperCase1 = 0; int camelBack = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiCamelBack = 0; +// CHECK-FIXES: {{^}}int myiCamelBack = 0; int camelBack_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiCamelBack1 = 0; +// CHECK-FIXES: {{^}}int myiCamelBack1 = 0; int camelBack2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiCamelBack2 = 0; +// CHECK-FIXES: {{^}}int myiCamelBack2 = 0; int CamelCase = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiCamelCase = 0; +// CHECK-FIXES: {{^}}int myiCamelCase = 0; int CamelCase_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiCamelCase1 = 0; +// CHECK-FIXES: {{^}}int myiCamelCase1 = 0; int CamelCase2 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase2' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiCamelCase2 = 0; +// CHECK-FIXES: {{^}}int myiCamelCase2 = 0; int camel_Snake_Back = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiCamelSnakeBack = 0; +// CHECK-FIXES: {{^}}int myiCamelSnakeBack = 0; int camel_Snake_Back_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camel_Snake_Back_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiCamelSnakeBack1 = 0; +// CHECK-FIXES: {{^}}int myiCamelSnakeBack1 = 0; int Camel_Snake_Case = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiCamelSnakeCase = 0; +// CHECK-FIXES: {{^}}int myiCamelSnakeCase = 0; int Camel_Snake_Case_1 = 0; // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Camel_Snake_Case_1' [readability-identifier-naming] -// CHECK-FIXES: {{^}}int custiCamelSnakeCase1 = 0; +// CHECK-FIXES: {{^}}int myiCamelSnakeCase1 = 0; //===----------------------------------------------------------------------===// // Enum