[clang-tidy] Fix readability-identifer-naming Hungarian CString options

[amurzeau]

Summary

When reading readability-identifier-naming.HungarianNotation.CString
options, correctly use the type string stored in CStr.second instead of
the option name (CStr.first) as the HNOption.CString map key.

This will make CString options really working and properly parsed by the
checker.

[carlosgalvezp]

Please document fix in the Release Notes, as people might have adopted to the buggy behavior and should know they need to change to the proper one.

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

118–125

These changes generate a lot of review noise and don't seem to be related to the fix in the patch (which has to do with HungarianNotation.General. Please revert them and if wanted make another patch just for that.

[amurzeau]

Remove test changes, I will make a different patch for that.

[amurzeau]

Add a release note for this fix.

[carlosgalvezp]

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

115

Sorry, maybe I wasn't clear. Isn't this line meant to stay, since this is what the patch is fixing?

[amurzeau]

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

115

The patch only fixes reading readability-identifier-naming.HungarianNotation.CString.* options.

I've updated the test completely to make options parsing issues tested.
The test was not catching the issue with HungarianNotation.CString.* because all options were set to their default value in this .clang-tidy file, so the test couldn't really check that the option was really correctly read (and it turns out it wasn't for HungarianNotation.CString.*).

This one (readability-identifier-naming.HungarianNotation.General.TreatStructAsClass) is correctly read, but was just misnamed in this test file with Options instead of General.
I found that while updating this test.

Both the code and docs currently use readability-identifier-naming.HungarianNotation.General.TreatStructAsClass.

The minimal changes in this test that reproduce the exact issue that is fixed here are the changes on readability-identifier-naming.HungarianNotation.CString.* options.
But I found it weird to just test them without updating all other options as well, that's why I've updated all options instead.

[carlosgalvezp]

Alright, sounds good, thanks for the clarification! Then I misunderstood the change in the tests and indeed it belonged together in this patch, sorry for the confusion. I have approved both patches so we can land them now. Can you land the patch or would you like me to do it for you? If so please provide name and email (same as your Github account) for attribution.

[amurzeau]

In D144431#4146524, @carlosgalvezp wrote:

Alright, sounds good, thanks for the clarification! Then I misunderstood the change in the tests and indeed it belonged together in this patch, sorry for the confusion. I have approved both patches so we can land them now. Can you land the patch or would you like me to do it for you? If so please provide name and email (same as your Github account) for attribution.

No worries, yes please land the patches for me as Alexis Murzeau <[e-mail]> (phabricator mail and handle is the same as github).
Thanks!

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

void IdentifierNamingCheck::HungarianNotation::loadFileConfig(
 
   Buffer = {Section, "CString."};
   DefSize = Buffer.size();
   for (const auto &CStr : HNCStrings) {
     Buffer.truncate(DefSize);
     Buffer.append(CStr.first);
     StringRef Val = Options.get(Buffer, "");
     if (!Val.empty())
-      HNOption.CString[CStr.first] = Val.str();
+      HNOption.CString[CStr.second] = Val.str();
   }
 
   Buffer = {Section, "PrimitiveType."};
   DefSize = Buffer.size();
   for (const auto &PrimType : HungarainNotationPrimitiveTypes) {
     Buffer.truncate(DefSize);
     Buffer.append(PrimType);
     StringRef Val = Options.get(Buffer, "");

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

CheckOptions:
   - 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
-  - key:    readability-identifier-naming.HungarianNotation.Options.TreatStructAsClass
-    value:  false
+  - key:    readability-identifier-naming.HungarianNotation.General.TreatStructAsClass
+    value:  true
   - key:    readability-identifier-naming.HungarianNotation.DerivedType.Array
-    value:  ary
+    value:  custa
   - key:    readability-identifier-naming.HungarianNotation.DerivedType.Pointer
-    value:  p
+    value:  custp
   - key:    readability-identifier-naming.HungarianNotation.DerivedType.FunctionPointer
-    value:  fn
+    value:  custfn
   - key:    readability-identifier-naming.HungarianNotation.CString.CharPrinter
-    value:  sz
+    value:  custsz
   - key:    readability-identifier-naming.HungarianNotation.CString.CharArray
-    value:  sz
+    value:  custsz
   - key:    readability-identifier-naming.HungarianNotation.CString.WideCharPrinter
-    value:  wsz
+    value:  custwsz
   - key:    readability-identifier-naming.HungarianNotation.CString.WideCharArray
-    value:  wsz
+    value:  custwsz
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.int8_t
-    value:  i8
+    value:  custi8
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.int16_t
-    value:  i16
+    value:  custi16
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.int32_t
-    value:  i32
+    value:  custi32
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.int64_t
-    value:  i64
+    value:  custi64
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.uint8_t
-    value:  u8
+    value:  custu8
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.uint16_t
-    value:  u16
+    value:  custu16
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.uint32_t
-    value:  u32
+    value:  custu32
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.uint64_t
-    value:  u64
+    value:  custu64
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.char8_t
-    value:  c8
+    value:  custc8
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.char16_t
-    value:  c16
+    value:  custc16
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.char32_t
-    value:  c32
+    value:  custc32
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.float
-    value:  f
+    value:  custf
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.double
-    value:  d
+    value:  custd
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.char
-    value:  c
+    value:  custc
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.bool
-    value:  b
+    value:  custb
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType._Bool
-    value:  b
+    value:  custb
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.int
-    value:  i
+    value:  custi
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.size_t
-    value:  n
+    value:  custn
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.wchar_t
-    value:  wc
+    value:  custwc
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.short-int
-    value:  si
+    value:  custsi
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.short
-    value:  s
+    value:  custs
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.signed-int
-    value:  si
+    value:  custsi
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.signed-short
-    value:  ss
+    value:  custss
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.signed-short-int
-    value:  ssi
+    value:  custssi
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-long-int
-    value:  slli
+    value:  custslli
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-long
-    value:  sll
+    value:  custsll
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long-int
-    value:  sli
+    value:  custsli
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.signed-long
-    value:  sl
+    value:  custsl
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.signed
-    value:  s
+    value:  custs
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-long-int
-    value:  ulli
+    value:  custulli
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-long
-    value:  ull
+    value:  custull
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long-int
-    value:  uli
+    value:  custuli
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-long
-    value:  ul
+    value:  custul
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-short-int
-    value:  usi
+    value:  custusi
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-short
-    value:  us
+    value:  custus
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-int
-    value:  ui
+    value:  custui
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned-char
-    value:  uc
+    value:  custuc
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.unsigned
-    value:  u
+    value:  custu
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.long-long-int
-    value:  lli
+    value:  custlli
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.long-double
-    value:  ld
+    value:  custld
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.long-long
-    value:  ll
+    value:  custll
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.long-int
-    value:  li
+    value:  custli
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.long
-    value:  l
+    value:  custl
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.ptrdiff_t
-    value:  p
+    value:  custp
   - key:    readability-identifier-naming.HungarianNotation.PrimitiveType.void
-    value:  v
+    value:  custv
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.BOOL
-    value:  b
+    value:  custb
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.BOOLEAN
-    value:  b
+    value:  custb
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.BYTE
-    value:  by
+    value:  custby
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.CHAR
-    value:  c
+    value:  custc
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.UCHAR
-    value:  uc
+    value:  custuc
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.SHORT
-    value:  s
+    value:  custs
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.USHORT
-    value:  us
+    value:  custus
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.WORD
-    value:  w
+    value:  custw
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD
-    value:  dw
+    value:  custdw
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD32
-    value:  dw32
+    value:  custdw32
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.DWORD64
-    value:  dw64
+    value:  custdw64
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.LONG
-    value:  l
+    value:  custl
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG
-    value:  ul
+    value:  custul
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG32
-    value:  ul32
+    value:  custul32
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.ULONG64
-    value:  ul64
+    value:  custul64
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.ULONGLONG
-    value:  ull
+    value:  custull
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.HANDLE
-    value:  h
+    value:  custh
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.INT
-    value:  i
+    value:  custi
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.INT8
-    value:  i8
+    value:  custi8
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.INT16
-    value:  i16
+    value:  custi16
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.INT32
-    value:  i32
+    value:  custi32
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.INT64
-    value:  i64
+    value:  custi64
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.UINT
-    value:  ui
+    value:  custui
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.UINT8
-    value:  u8
+    value:  custu8
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.UINT16
-    value:  u16
+    value:  custu16
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.UINT32
-    value:  u32
+    value:  custu32
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.UINT64
-    value:  u64
+    value:  custu64
   - key:    readability-identifier-naming.HungarianNotation.UserDefinedType.PVOID
-    value:  p
+    value:  custp

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

 // clang-format off
 //===----------------------------------------------------------------------===//
 // Cases to CheckOptions
 //===----------------------------------------------------------------------===//
 class CMyClass1 {
 public:
   static int ClassMemberCase;
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for class member 'ClassMemberCase' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  static int iClassMemberCase;
+  // CHECK-FIXES: {{^}}  static int custiClassMemberCase;
 
   char const ConstantMemberCase = 0;
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for constant member 'ConstantMemberCase' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  char const cConstantMemberCase = 0;
+  // CHECK-FIXES: {{^}}  char const custcConstantMemberCase = 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 iConstantParameterCase);
+  // CHECK-FIXES: {{^}}  void MyFunc1(const int custiConstantParameterCase);
 
   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* piConstantPointerParameterCase);
+  // CHECK-FIXES: {{^}}  void MyFunc2(const int* custpcustiConstantPointerParameterCase);
 
   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 iConstexprVariableCase = 123;
+  // CHECK-FIXES: {{^}}  static constexpr int custiConstexprVariableCase = 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 iGlobalConstantCase = 0;
+// CHECK-FIXES: {{^}}const int custiGlobalConstantCase = 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* piGlobalConstantPointerCase = nullptr;
+// CHECK-FIXES: {{^}}const int* custpcustiGlobalConstantPointerCase = nullptr;
 
 int* GlobalPointerCase = nullptr;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'GlobalPointerCase' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int* piGlobalPointerCase = nullptr;
+// CHECK-FIXES: {{^}}int* custpcustiGlobalPointerCase = nullptr;
 
 int GlobalVariableCase = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'GlobalVariableCase' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int iGlobalVariableCase = 0;
+// CHECK-FIXES: {{^}}int custiGlobalVariableCase = 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 iLocalConstantCase = 3;
+  // CHECK-FIXES: {{^}}  int const custiLocalConstantCase = 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 uConstantCase = 1;
+  // CHECK-FIXES: {{^}}  unsigned const custuConstantCase = 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 piLocalConstantPointerCase = nullptr;
+  // CHECK-FIXES: {{^}}  int* const custpcustiLocalConstantPointerCase = nullptr;
 
   int *LocalPointerCase = nullptr;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for local pointer 'LocalPointerCase' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  int *piLocalPointerCase = nullptr;
+  // CHECK-FIXES: {{^}}  int *custpcustiLocalPointerCase = nullptr;
 
   int LocalVariableCase = 0;
   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for local variable 'LocalVariableCase' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  int iLocalVariableCase = 0;
+  // CHECK-FIXES: {{^}}  int custiLocalVariableCase = 0;
 }
 
 class CMyClass2 {
   char MemberCase;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'MemberCase' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  char cMemberCase;
+  // CHECK-FIXES: {{^}}  char custcMemberCase;
 
   void Func1(int ParameterCase);
   // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for parameter 'ParameterCase' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  void Func1(int iParameterCase);
+  // CHECK-FIXES: {{^}}  void Func1(int custiParameterCase);
 
   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 iParameterCase);
+  // CHECK-FIXES: {{^}}  void Func2(const int custiParameterCase);
 
   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 *piPointerParameterCase);
+  // CHECK-FIXES: {{^}}  void Func3(const int *custpcustiPointerParameterCase);
 };
 
 class CMyClass3 {
 private:
   char PrivateMemberCase;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for private member 'PrivateMemberCase' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  char cPrivateMemberCase;
+  // CHECK-FIXES: {{^}}  char custcPrivateMemberCase;
 
 protected:
   char ProtectedMemberCase;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for protected member 'ProtectedMemberCase' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  char cProtectedMemberCase;
+  // CHECK-FIXES: {{^}}  char custcProtectedMemberCase;
 
 public:
   char PublicMemberCase;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for public member 'PublicMemberCase' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  char cPublicMemberCase;
+  // CHECK-FIXES: {{^}}  char custcPublicMemberCase;
 };
 
 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 iStaticConstantCase = 3;
+// CHECK-FIXES: {{^}}static const int custiStaticConstantCase = 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 iStaticVariableCase = 3;
+// CHECK-FIXES: {{^}}static int custiStaticVariableCase = 3;
 
-struct MyStruct { int StructCase; };
-// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: invalid case style for public member 'StructCase' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}struct MyStruct { int iStructCase; };
+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; };
 
-union MyUnion { int UnionCase; long lUnionCase; };
+union MyUnion { int UnionCase; long custlUnionCase; };
 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for public member 'UnionCase' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}union MyUnion { int iUnionCase; long lUnionCase; };
+// CHECK-FIXES: {{^}}union MyUnion { int custiUnionCase; long custlUnionCase; };
 
 //===----------------------------------------------------------------------===//
 // 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 *szNamePtr = "Name";
+// CHECK-FIXES: {{^}}const char *custszNamePtr = "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 szNameArray[] = "Name";
+// CHECK-FIXES: {{^}}const char custszNameArray[] = "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 *pszNamePtrArray[] = {"AA", "BB"};
+// CHECK-FIXES: {{^}}const char *custpcustszNamePtrArray[] = {"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 *wszWideNamePtr = L"Name";
+// CHECK-FIXES: {{^}}const wchar_t *custwszWideNamePtr = 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 wszWideNameArray[] = L"Name";
+// CHECK-FIXES: {{^}}const wchar_t custwszWideNameArray[] = 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 *pwszWideNamePtrArray[] = {L"AA", L"BB"};
+// CHECK-FIXES: {{^}}const wchar_t *custpcustwszWideNamePtrArray[] = {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 *szName = "Text";
+  // CHECK-FIXES: {{^}}  char *custszName = "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 *szConstName = "Text";
+  // CHECK-FIXES: {{^}}  const char *custszConstName = "Text";
 
 public:
-  const char* DuplicateString(const char* Input, size_t nRequiredSize);
+  const char* DuplicateString(const char* Input, size_t custnRequiredSize);
   // CHECK-MESSAGES: :[[@LINE-1]]:43: warning: invalid case style for pointer parameter 'Input' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  const char* DuplicateString(const char* szInput, size_t nRequiredSize);
+  // CHECK-FIXES: {{^}}  const char* DuplicateString(const char* custszInput, size_t custnRequiredSize);
 
-  size_t UpdateText(const char* Buffer, size_t nBufferSize);
+  size_t UpdateText(const char* Buffer, size_t custnBufferSize);
   // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: invalid case style for pointer parameter 'Buffer' [readability-identifier-naming]
-  // CHECK-FIXES: {{^}}  size_t UpdateText(const char* szBuffer, size_t nBufferSize);
+  // CHECK-FIXES: {{^}}  size_t UpdateText(const char* custszBuffer, size_t custnBufferSize);
 };
 
 
 //===----------------------------------------------------------------------===//
 // Microsoft Windows data types
 //===----------------------------------------------------------------------===//
 DWORD MsDword = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsDword' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}DWORD dwMsDword = 0;
+// CHECK-FIXES: {{^}}DWORD custdwMsDword = 0;
 
 BYTE MsByte = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsByte' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}BYTE byMsByte = 0;
+// CHECK-FIXES: {{^}}BYTE custbyMsByte = 0;
 
 WORD MsWord = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsWord' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}WORD wMsWord = 0;
+// CHECK-FIXES: {{^}}WORD custwMsWord = 0;
 
 BOOL MsBool = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsBool' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}BOOL bMsBool = 0;
+// CHECK-FIXES: {{^}}BOOL custbMsBool = 0;
 
 BOOLEAN MsBoolean = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsBoolean' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}BOOLEAN bMsBoolean = 0;
+// CHECK-FIXES: {{^}}BOOLEAN custbMsBoolean = 0;
 
 CHAR MsValueChar = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueChar' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}CHAR cMsValueChar = 0;
+// CHECK-FIXES: {{^}}CHAR custcMsValueChar = 0;
 
 UCHAR MsValueUchar = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUchar' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}UCHAR ucMsValueUchar = 0;
+// CHECK-FIXES: {{^}}UCHAR custucMsValueUchar = 0;
 
 SHORT MsValueShort = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueShort' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}SHORT sMsValueShort = 0;
+// CHECK-FIXES: {{^}}SHORT custsMsValueShort = 0;
 
 USHORT MsValueUshort = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUshort' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}USHORT usMsValueUshort = 0;
+// CHECK-FIXES: {{^}}USHORT custusMsValueUshort = 0;
 
 WORD MsValueWord = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueWord' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}WORD wMsValueWord = 0;
+// CHECK-FIXES: {{^}}WORD custwMsValueWord = 0;
 
 DWORD MsValueDword = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueDword' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}DWORD dwMsValueDword = 0;
+// CHECK-FIXES: {{^}}DWORD custdwMsValueDword = 0;
 
 DWORD32 MsValueDword32 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword32' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}DWORD32 dw32MsValueDword32 = 0;
+// CHECK-FIXES: {{^}}DWORD32 custdw32MsValueDword32 = 0;
 
 DWORD64 MsValueDword64 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueDword64' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}DWORD64 dw64MsValueDword64 = 0;
+// CHECK-FIXES: {{^}}DWORD64 custdw64MsValueDword64 = 0;
 
 LONG MsValueLong = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueLong' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}LONG lMsValueLong = 0;
+// CHECK-FIXES: {{^}}LONG custlMsValueLong = 0;
 
 ULONG MsValueUlong = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUlong' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}ULONG ulMsValueUlong = 0;
+// CHECK-FIXES: {{^}}ULONG custulMsValueUlong = 0;
 
 ULONG32 MsValueUlong32 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong32' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}ULONG32 ul32MsValueUlong32 = 0;
+// CHECK-FIXES: {{^}}ULONG32 custul32MsValueUlong32 = 0;
 
 ULONG64 MsValueUlong64 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'MsValueUlong64' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}ULONG64 ul64MsValueUlong64 = 0;
+// CHECK-FIXES: {{^}}ULONG64 custul64MsValueUlong64 = 0;
 
 ULONGLONG MsValueUlongLong = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global variable 'MsValueUlongLong' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}ULONGLONG ullMsValueUlongLong = 0;
+// CHECK-FIXES: {{^}}ULONGLONG custullMsValueUlongLong = 0;
 
 HANDLE MsValueHandle = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'MsValueHandle' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}HANDLE hMsValueHandle = 0;
+// CHECK-FIXES: {{^}}HANDLE custhMsValueHandle = 0;
 
 INT MsValueInt = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'MsValueInt' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}INT iMsValueInt = 0;
+// CHECK-FIXES: {{^}}INT custiMsValueInt = 0;
 
 INT8 MsValueInt8 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueInt8' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}INT8 i8MsValueInt8 = 0;
+// CHECK-FIXES: {{^}}INT8 custi8MsValueInt8 = 0;
 
 INT16 MsValueInt16 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt16' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}INT16 i16MsValueInt16 = 0;
+// CHECK-FIXES: {{^}}INT16 custi16MsValueInt16 = 0;
 
 INT32 MsValueInt32 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueInt32' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}INT32 i32MsValueInt32 = 0;
+// CHECK-FIXES: {{^}}INT32 custi32MsValueInt32 = 0;
 
 INT64 MsValueINt64 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueINt64' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}INT64 i64MsValueINt64 = 0;
+// CHECK-FIXES: {{^}}INT64 custi64MsValueINt64 = 0;
 
 UINT MsValueUint = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'MsValueUint' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}UINT uiMsValueUint = 0;
+// CHECK-FIXES: {{^}}UINT custuiMsValueUint = 0;
 
 UINT8 MsValueUint8 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'MsValueUint8' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}UINT8 u8MsValueUint8 = 0;
+// CHECK-FIXES: {{^}}UINT8 custu8MsValueUint8 = 0;
 
 UINT16 MsValueUint16 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint16' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}UINT16 u16MsValueUint16 = 0;
+// CHECK-FIXES: {{^}}UINT16 custu16MsValueUint16 = 0;
 
 UINT32 MsValueUint32 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint32' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}UINT32 u32MsValueUint32 = 0;
+// CHECK-FIXES: {{^}}UINT32 custu32MsValueUint32 = 0;
 
 UINT64 MsValueUint64 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'MsValueUint64' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}UINT64 u64MsValueUint64 = 0;
+// CHECK-FIXES: {{^}}UINT64 custu64MsValueUint64 = 0;
 
 PVOID MsValuePvoid = NULL;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'MsValuePvoid' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}PVOID pMsValuePvoid = NULL;
+// CHECK-FIXES: {{^}}PVOID custpMsValuePvoid = NULL;
 
 
 //===----------------------------------------------------------------------===//
 // Array
 //===----------------------------------------------------------------------===//
 unsigned GlobalUnsignedArray[] = {1, 2, 3};
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'GlobalUnsignedArray' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}unsigned aryGlobalUnsignedArray[] = {1, 2, 3};
+// CHECK-FIXES: {{^}}unsigned custaGlobalUnsignedArray[] = {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 aryGlobalIntArray[] = {1, 2, 3};
+// CHECK-FIXES: {{^}}int custaGlobalIntArray[] = {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 aryDataInt[1] = {0};
+// CHECK-FIXES: {{^}}int custaDataInt[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 aryDataArray[2] = {0};
+// CHECK-FIXES: {{^}}int custaDataArray[2] = {0};
 
 
 //===----------------------------------------------------------------------===//
 // Pointer
 //===----------------------------------------------------------------------===//
 int *DataIntPtr[1] = {0};
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'DataIntPtr' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int *paryDataIntPtr[1] = {0};
+// CHECK-FIXES: {{^}}int *custpcustaDataIntPtr[1] = {0};
 
 void *BufferPtr1;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'BufferPtr1' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}void *pvBufferPtr1;
+// CHECK-FIXES: {{^}}void *custpcustvBufferPtr1;
 
 void **BufferPtr2;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'BufferPtr2' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}void **ppvBufferPtr2;
+// CHECK-FIXES: {{^}}void **custpcustpcustvBufferPtr2;
 
-void **pBufferPtr3;
-// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'pBufferPtr3' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}void **ppvBufferPtr3;
-
-int *pBufferPtr4;
-// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'pBufferPtr4' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int *piBufferPtr4;
+void **custpBufferPtr3;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'custpBufferPtr3' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void **custpcustpcustvBufferPtr3;
+
+int *custpBufferPtr4;
+// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'custpBufferPtr4' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}int *custpcustiBufferPtr4;
 
 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 fnHello = NULL;
+// CHECK-FIXES: {{^}}FUNC_PTR_HELLO custfnHello = NULL;
 
 void *ValueVoidPtr = NULL;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'ValueVoidPtr' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}void *pvValueVoidPtr = NULL;
+// CHECK-FIXES: {{^}}void *custpcustvValueVoidPtr = 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 pPtrDiff = NULL;
+// CHECK-FIXES: {{^}}ptrdiff_t custpPtrDiff = NULL;
 
 int8_t *ValueI8Ptr;
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global pointer 'ValueI8Ptr' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int8_t *pi8ValueI8Ptr;
+// CHECK-FIXES: {{^}}int8_t *custpcusti8ValueI8Ptr;
 
 uint8_t *ValueU8Ptr;
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global pointer 'ValueU8Ptr' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}uint8_t *pu8ValueU8Ptr;
+// CHECK-FIXES: {{^}}uint8_t *custpcustu8ValueU8Ptr;
 
 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* pvVal){}
+// CHECK-FIXES: {{^}}void MyFunc2(void* custpcustvVal){}
 
 
 //===----------------------------------------------------------------------===//
 // Reference
 //===----------------------------------------------------------------------===//
-int iValueIndex = 1;
-int &RefValueIndex = iValueIndex;
+int custiValueIndex = 1;
+int &RefValueIndex = custiValueIndex;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'RefValueIndex' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int &iRefValueIndex = iValueIndex;
+// CHECK-FIXES: {{^}}int &custiRefValueIndex = custiValueIndex;
 
-const int &ConstRefValue = iValueIndex;
+const int &ConstRefValue = custiValueIndex;
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ConstRefValue' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}const int &iConstRefValue = iValueIndex;
+// CHECK-FIXES: {{^}}const int &custiConstRefValue = custiValueIndex;
 
-long long llValueLongLong = 2;
-long long &RefValueLongLong = llValueLongLong;
+long long custllValueLongLong = 2;
+long long &RefValueLongLong = custllValueLongLong;
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'RefValueLongLong' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}long long &llRefValueLongLong = llValueLongLong;
+// CHECK-FIXES: {{^}}long long &custllRefValueLongLong = custllValueLongLong;
 
 
 //===----------------------------------------------------------------------===//
 // Various types
 //===----------------------------------------------------------------------===//
 int8_t ValueI8;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueI8' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int8_t i8ValueI8;
+// CHECK-FIXES: {{^}}int8_t custi8ValueI8;
 
 int16_t ValueI16 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for global variable 'ValueI16' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int16_t i16ValueI16 = 0;
+// CHECK-FIXES: {{^}}int16_t custi16ValueI16 = 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 i32ValueI32 = 0;
+// CHECK-FIXES: {{^}}int32_t custi32ValueI32 = 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 i64ValueI64 = 0;
+// CHECK-FIXES: {{^}}int64_t custi64ValueI64 = 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 u8ValueU8 = 0;
+// CHECK-FIXES: {{^}}uint8_t custu8ValueU8 = 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 u16ValueU16 = 0;
+// CHECK-FIXES: {{^}}uint16_t custu16ValueU16 = 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 u32ValueU32 = 0;
+// CHECK-FIXES: {{^}}uint32_t custu32ValueU32 = 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 u64ValueU64 = 0;
+// CHECK-FIXES: {{^}}uint64_t custu64ValueU64 = 0;
 
 float ValueFloat = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueFloat' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}float fValueFloat = 0;
+// CHECK-FIXES: {{^}}float custfValueFloat = 0;
 
 double ValueDouble = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueDouble' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}double dValueDouble = 0;
+// CHECK-FIXES: {{^}}double custdValueDouble = 0;
 
 char ValueChar = 'c';
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueChar' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}char cValueChar = 'c';
+// CHECK-FIXES: {{^}}char custcValueChar = 'c';
 
 bool ValueBool = true;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueBool' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}bool bValueBool = true;
+// CHECK-FIXES: {{^}}bool custbValueBool = true;
 
 int ValueInt = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'ValueInt' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int iValueInt = 0;
+// CHECK-FIXES: {{^}}int custiValueInt = 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 nValueSize = 0;
+// CHECK-FIXES: {{^}}size_t custnValueSize = 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 wcValueWchar = 'w';
+// CHECK-FIXES: {{^}}wchar_t custwcValueWchar = 'w';
 
 short ValueShort = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'ValueShort' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}short sValueShort = 0;
+// CHECK-FIXES: {{^}}short custsValueShort = 0;
 
 unsigned ValueUnsigned = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'ValueUnsigned' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}unsigned uValueUnsigned = 0;
+// CHECK-FIXES: {{^}}unsigned custuValueUnsigned = 0;
 
 signed ValueSigned = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global variable 'ValueSigned' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}signed sValueSigned = 0;
+// CHECK-FIXES: {{^}}signed custsValueSigned = 0;
 
 long ValueLong = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global variable 'ValueLong' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}long lValueLong = 0;
+// CHECK-FIXES: {{^}}long custlValueLong = 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 llValueLongLong = 0;
+// CHECK-FIXES: {{^}}long long custllValueLongLong = 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 lliValueLongLongInt = 0;
+// CHECK-FIXES: {{^}}long long int custlliValueLongLongInt = 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 ldValueLongDouble = 0;
+// CHECK-FIXES: {{^}}long double custldValueLongDouble = 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 siValueSignedInt = 0;
+// CHECK-FIXES: {{^}}signed int custsiValueSignedInt = 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 ssValueSignedShort = 0;
+// CHECK-FIXES: {{^}}signed short custssValueSignedShort = 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 ssiValueSignedShortInt = 0;
+// CHECK-FIXES: {{^}}signed short int custssiValueSignedShortInt = 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 sllValueSignedLongLong = 0;
+// CHECK-FIXES: {{^}}signed long long custsllValueSignedLongLong = 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 sliValueSignedLongInt = 0;
+// CHECK-FIXES: {{^}}signed long int custsliValueSignedLongInt = 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 slValueSignedLong = 0;
+// CHECK-FIXES: {{^}}signed long custslValueSignedLong = 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 ulliValueUnsignedLongLongInt = 0;
+// CHECK-FIXES: {{^}}unsigned long long int custulliValueUnsignedLongLongInt = 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 ullValueUnsignedLongLong = 0;
+// CHECK-FIXES: {{^}}unsigned long long custullValueUnsignedLongLong = 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 uliValueUnsignedLongInt = 0;
+// CHECK-FIXES: {{^}}unsigned long int custuliValueUnsignedLongInt = 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 ulValueUnsignedLong = 0;
+// CHECK-FIXES: {{^}}unsigned long custulValueUnsignedLong = 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 usiValueUnsignedShortInt = 0;
+// CHECK-FIXES: {{^}}unsigned short int custusiValueUnsignedShortInt = 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 usValueUnsignedShort = 0;
+// CHECK-FIXES: {{^}}unsigned short custusValueUnsignedShort = 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 uiValueUnsignedInt = 0;
+// CHECK-FIXES: {{^}}unsigned int custuiValueUnsignedInt = 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 ucValueUnsignedChar = 0;
+// CHECK-FIXES: {{^}}unsigned char custucValueUnsignedChar = 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 liValueLongInt = 0;
+// CHECK-FIXES: {{^}}long int custliValueLongInt = 0;
 
 
 //===----------------------------------------------------------------------===//
 // Specifier, Qualifier, Other keywords
 //===----------------------------------------------------------------------===//
 volatile int VolatileInt = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'VolatileInt' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}volatile int iVolatileInt = 0;
+// CHECK-FIXES: {{^}}volatile int custiVolatileInt = 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 iThreadLocalValueInt = 0;
+// CHECK-FIXES: {{^}}thread_local int custiThreadLocalValueInt = 0;
 
 extern int ExternValueInt;
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'ExternValueInt' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}extern int iExternValueInt;
+// CHECK-FIXES: {{^}}extern int custiExternValueInt;
 
-struct DataBuffer {
+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 nSize;
+// CHECK-FIXES: {{^}}    mutable size_t custnSize;
 
 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 &iConstExprInt = 42;
+// CHECK-FIXES: {{^}}static constexpr int const &custiConstExprInt = 42;
 
 
 //===----------------------------------------------------------------------===//
 // Redefined types
 //===----------------------------------------------------------------------===//
 typedef int INDEX;
-INDEX iIndex = 0;
-// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'iIndex' [readability-identifier-naming]
+INDEX custiIndex = 0;
+// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global variable 'custiIndex' [readability-identifier-naming]
 // CHECK-FIXES: {{^}}INDEX Index = 0;
 
 
 //===----------------------------------------------------------------------===//
-// Class
+// Class and struct
 //===----------------------------------------------------------------------===//
 class ClassCase { int Func(); };
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'ClassCase' [readability-identifier-naming]
 // CHECK-FIXES: {{^}}class CClassCase { int Func(); };
 
 class AbstractClassCase { virtual int Func() = 0; };
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'AbstractClassCase' [readability-identifier-naming]
 // CHECK-FIXES: {{^}}class IAbstractClassCase { virtual int Func() = 0; };
 
 class AbstractClassCase1 { virtual int Func1() = 0; int Func2(); };
 // 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 iConstantCase; };
+class ClassConstantCase { public: static const int custiConstantCase; };
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'ClassConstantCase' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}class CClassConstantCase { public: static const int iConstantCase; };
+// CHECK-FIXES: {{^}}class CClassConstantCase { public: static const int custiConstantCase; };
+
+struct StructCase { int Func(); };
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for class 'StructCase' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}struct CStructCase { int Func(); };
 
 //===----------------------------------------------------------------------===//
 // Other Cases
 //===----------------------------------------------------------------------===//
 int lower_case = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'lower_case' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int iLowerCase = 0;
+// CHECK-FIXES: {{^}}int custiLowerCase = 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 iLowerCase1 = 0;
+// CHECK-FIXES: {{^}}int custiLowerCase1 = 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 iLowerCase2 = 0;
+// CHECK-FIXES: {{^}}int custiLowerCase2 = 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 iUpperCase = 0;
+// CHECK-FIXES: {{^}}int custiUpperCase = 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 iUpperCase1 = 0;
+// CHECK-FIXES: {{^}}int custiUpperCase1 = 0;
 
 int camelBack = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int iCamelBack = 0;
+// CHECK-FIXES: {{^}}int custiCamelBack = 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 iCamelBack1 = 0;
+// CHECK-FIXES: {{^}}int custiCamelBack1 = 0;
 
 int camelBack2 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'camelBack2' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int iCamelBack2 = 0;
+// CHECK-FIXES: {{^}}int custiCamelBack2 = 0;
 
 int CamelCase = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int iCamelCase = 0;
+// CHECK-FIXES: {{^}}int custiCamelCase = 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 iCamelCase1 = 0;
+// CHECK-FIXES: {{^}}int custiCamelCase1 = 0;
 
 int CamelCase2 = 0;
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'CamelCase2' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int iCamelCase2 = 0;
+// CHECK-FIXES: {{^}}int custiCamelCase2 = 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 iCamelSnakeBack = 0;
+// CHECK-FIXES: {{^}}int custiCamelSnakeBack = 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 iCamelSnakeBack1 = 0;
+// CHECK-FIXES: {{^}}int custiCamelSnakeBack1 = 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 iCamelSnakeCase = 0;
+// CHECK-FIXES: {{^}}int custiCamelSnakeCase = 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 iCamelSnakeCase1 = 0;
+// CHECK-FIXES: {{^}}int custiCamelSnakeCase1 = 0;
 
 //===----------------------------------------------------------------------===//
 // Enum
 //===----------------------------------------------------------------------===//
 enum REV_TYPE { RevValid };
 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for enum constant 'RevValid' [readability-identifier-naming]
 // CHECK-FIXES: {{^}}enum REV_TYPE { rtRevValid };