[clang-tidy][NFC] Improved hungarian notation regression test at post-commit review

[dougpuob]

Summary

Improve the (D144510)[https://reviews.llvm.org/D144510] patch with prefix string. Using "my" instead of "cust" would increase
readability.

Take some examples:

• const char* custszNamePtr = "Name"; --> myszNamePtr
• uint8_t custu8ValueU8 = 0; --> myu8ValueU8
• DWORD custdwMsDword = 0; --> mydwMsDword

[PiotrZSL]

clang-tools-extra/docs/ReleaseNotes.rst

264–267 ↗

(On Diff #513492)

Don't put this into release notes, in release notes we put only information that impact users.

[PiotrZSL]

And you forget to attach changes in unit tests.

[dougpuob]

Against trunk.

[dougpuob]

In D148314#4267567, @PiotrZSL wrote:

And you forget to attach changes in unit tests.

My bad, I against to a wrong one.

clang-tools-extra/docs/ReleaseNotes.rst

264–267 ↗

(On Diff #513492)

Make sense, I will remove it in next commit.

[PiotrZSL]

Change in tests is ok, change in release notes not needed (please remove).
Change title into [clang-tidy][NFC] Improved ...

NFC - Non Functional Change

[dougpuob]

• Removed unnecessary information from ReleaseNotes.rst

[dougpuob]

In D148314#4268460, @PiotrZSL wrote:

Change in tests is ok, change in release notes not needed (please remove).
Change title into [clang-tidy][NFC] Improved ...

NFC - Non Functional Change

Thank you for the review :)
I removed the release notes and changed the title.

[PiotrZSL]

I will push into repository this in a moment....

[dougpuob]

In D148314#4268989, @PiotrZSL wrote:

I will push into repository this in a moment....

@PiotrZSL, Thank you.

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

- 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.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

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

 // RUN: %check_clang_tidy %s readability-identifier-naming %t -- \
 // RUN:   --config-file=%S/Inputs/identifier-naming/hungarian-notation2/.clang-tidy -- -I %S
 
 #include "identifier-naming-standard-types.h"
 
 // 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 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);
 };
 
 
 //===----------------------------------------------------------------------===//
 // 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 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;
 
 
 //===----------------------------------------------------------------------===//
 // 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 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};
 
 
 //===----------------------------------------------------------------------===//
 // Pointer
 //===----------------------------------------------------------------------===//
 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;
-
-int *custpBufferPtr4;
-// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global pointer 'custpBufferPtr4' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}int *custpcustiBufferPtr4;
+void **mypBufferPtr3;
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for global pointer 'mypBufferPtr3' [readability-identifier-naming]
+// CHECK-FIXES: {{^}}void **mypmypmyvBufferPtr3;
+
+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;
 
 
 //===----------------------------------------------------------------------===//
 // 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 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;
 
 
 //===----------------------------------------------------------------------===//
 // 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 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;
 
 
 //===----------------------------------------------------------------------===//
 // 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 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]
 // 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 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
 //===----------------------------------------------------------------------===//
 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 };