[analyzer] Fix 'Memory Error' bugtype capitalization.

[NoQ]

Summary

It seems that we're not capitalizing every word in our bug type descriptions, however Memory Error is an exception from this rule. Additionally, one of the nullability checkers actually does spell it as Memory error. So i guess it's better to keep everything consistent.

[xazax.hun]

LGTM!

[a.sidorin]

Hi Artem. It is a good point but I think we should have a literal for this instead.

[zaks.anna]

Thanks!

[NoQ]

Added a reusable bug category.

[a.sidorin]

Thank you!

[xazax.hun]

Even better :)

cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/CommonBugCategories.h

 
 // Common strings used for the "category" of many static analyzer issues.
 namespace clang {
   namespace ento {
     namespace categories {
       extern const char * const CoreFoundationObjectiveC;
       extern const char * const LogicError;
       extern const char * const MemoryCoreFoundationObjectiveC;
+      extern const char * const MemoryError;
       extern const char * const UnixAPI;
     }
   }
 }
 #endif
 

cfe/trunk/lib/StaticAnalyzer/Checkers/MallocChecker.cpp

 
 #include "ClangSACheckers.h"
 #include "InterCheckerAPI.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
+#include "clang/StaticAnalyzer/Core/BugReporter/CommonBugCategories.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
 #include "llvm/ADT/STLExtras.h"
void MallocChecker::ReportBadFree(CheckerContext &C, SVal ArgVal,
 
   Optional<MallocChecker::CheckKind> CheckKind =
       getCheckIfTracked(C, DeallocExpr);
   if (!CheckKind.hasValue())
     return;
 
   if (ExplodedNode *N = C.generateErrorNode()) {
     if (!BT_BadFree[*CheckKind])
-      BT_BadFree[*CheckKind].reset(
-          new BugType(CheckNames[*CheckKind], "Bad free", "Memory Error"));
+      BT_BadFree[*CheckKind].reset(new BugType(
+          CheckNames[*CheckKind], "Bad free", categories::MemoryError));
 
     SmallString<100> buf;
     llvm::raw_svector_ostream os(buf);
 
     const MemRegion *MR = ArgVal.getAsRegion();
     while (const ElementRegion *ER = dyn_cast_or_null<ElementRegion>(MR))
       MR = ER->getSuperRegion();
 
if (ChecksEnabled[CK_MallocChecker])
     CheckKind = CK_MallocChecker;
   else if (ChecksEnabled[CK_MismatchedDeallocatorChecker])
     CheckKind = CK_MismatchedDeallocatorChecker;
   else
     return;
 
   if (ExplodedNode *N = C.generateErrorNode()) {
     if (!BT_FreeAlloca[*CheckKind])
-      BT_FreeAlloca[*CheckKind].reset(
-          new BugType(CheckNames[*CheckKind], "Free alloca()", "Memory Error"));
+      BT_FreeAlloca[*CheckKind].reset(new BugType(
+          CheckNames[*CheckKind], "Free alloca()", categories::MemoryError));
 
     auto R = llvm::make_unique<BugReport>(
         *BT_FreeAlloca[*CheckKind],
         "Memory allocated by alloca() should not be deallocated", N);
     R->markInteresting(ArgVal.getAsRegion());
     R->addRange(Range);
     C.emitReport(std::move(R));
   }
 }
 
 void MallocChecker::ReportMismatchedDealloc(CheckerContext &C,
                                             SourceRange Range,
                                             const Expr *DeallocExpr,
                                             const RefState *RS,
                                             SymbolRef Sym,
                                             bool OwnershipTransferred) const {
 
   if (!ChecksEnabled[CK_MismatchedDeallocatorChecker])
     return;
 
   if (ExplodedNode *N = C.generateErrorNode()) {
     if (!BT_MismatchedDealloc)
       BT_MismatchedDealloc.reset(
           new BugType(CheckNames[CK_MismatchedDeallocatorChecker],
-                      "Bad deallocator", "Memory Error"));
+                      "Bad deallocator", categories::MemoryError));
 
     SmallString<100> buf;
     llvm::raw_svector_ostream os(buf);
 
     const Expr *AllocExpr = cast<Expr>(RS->getStmt());
     SmallString<20> AllocBuf;
     llvm::raw_svector_ostream AllocOs(AllocBuf);
     SmallString<20> DeallocBuf;
void MallocChecker::ReportOffsetFree(CheckerContext &C, SVal ArgVal,
   if (!CheckKind.hasValue())
     return;
 
   ExplodedNode *N = C.generateErrorNode();
   if (!N)
     return;
 
   if (!BT_OffsetFree[*CheckKind])
-    BT_OffsetFree[*CheckKind].reset(
-        new BugType(CheckNames[*CheckKind], "Offset free", "Memory Error"));
+    BT_OffsetFree[*CheckKind].reset(new BugType(
+        CheckNames[*CheckKind], "Offset free", categories::MemoryError));
 
   SmallString<100> buf;
   llvm::raw_svector_ostream os(buf);
   SmallString<20> AllocNameBuf;
   llvm::raw_svector_ostream AllocNameOs(AllocNameBuf);
 
   const MemRegion *MR = ArgVal.getAsRegion();
   assert(MR && "Only MemRegion based symbols can have offset free errors");
void MallocChecker::ReportUseAfterFree(CheckerContext &C, SourceRange Range,
 
   Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
   if (!CheckKind.hasValue())
     return;
 
   if (ExplodedNode *N = C.generateErrorNode()) {
     if (!BT_UseFree[*CheckKind])
       BT_UseFree[*CheckKind].reset(new BugType(
-          CheckNames[*CheckKind], "Use-after-free", "Memory Error"));
+          CheckNames[*CheckKind], "Use-after-free", categories::MemoryError));
 
     auto R = llvm::make_unique<BugReport>(*BT_UseFree[*CheckKind],
                                          "Use of memory after it is freed", N);
 
     R->markInteresting(Sym);
     R->addRange(Range);
     R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym));
     C.emitReport(std::move(R));
if (!ChecksEnabled[CK_MallocChecker] &&
     return;
 
   Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
   if (!CheckKind.hasValue())
     return;
 
   if (ExplodedNode *N = C.generateErrorNode()) {
     if (!BT_DoubleFree[*CheckKind])
-      BT_DoubleFree[*CheckKind].reset(
-          new BugType(CheckNames[*CheckKind], "Double free", "Memory Error"));
+      BT_DoubleFree[*CheckKind].reset(new BugType(
+          CheckNames[*CheckKind], "Double free", categories::MemoryError));
 
     auto R = llvm::make_unique<BugReport>(
         *BT_DoubleFree[*CheckKind],
         (Released ? "Attempt to free released memory"
                   : "Attempt to free non-owned memory"),
         N);
     R->addRange(Range);
     R->markInteresting(Sym);
void MallocChecker::ReportDoubleDelete(CheckerContext &C, SymbolRef Sym) const {
 
   Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
   if (!CheckKind.hasValue())
     return;
 
   if (ExplodedNode *N = C.generateErrorNode()) {
     if (!BT_DoubleDelete)
       BT_DoubleDelete.reset(new BugType(CheckNames[CK_NewDeleteChecker],
-                                        "Double delete", "Memory Error"));
+                                        "Double delete",
+                                        categories::MemoryError));
 
     auto R = llvm::make_unique<BugReport>(
         *BT_DoubleDelete, "Attempt to delete released memory", N);
 
     R->markInteresting(Sym);
     R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym));
     C.emitReport(std::move(R));
   }
void MallocChecker::ReportUseZeroAllocated(CheckerContext &C,
 
   Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
 
   if (!CheckKind.hasValue())
     return;
 
   if (ExplodedNode *N = C.generateErrorNode()) {
     if (!BT_UseZerroAllocated[*CheckKind])
-      BT_UseZerroAllocated[*CheckKind].reset(new BugType(
-          CheckNames[*CheckKind], "Use of zero allocated", "Memory Error"));
+      BT_UseZerroAllocated[*CheckKind].reset(
+          new BugType(CheckNames[*CheckKind], "Use of zero allocated",
+                      categories::MemoryError));
 
     auto R = llvm::make_unique<BugReport>(*BT_UseZerroAllocated[*CheckKind],
                                          "Use of zero-allocated memory", N);
 
     R->addRange(Range);
     if (Sym) {
       R->markInteresting(Sym);
       R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym));
void MallocChecker::reportLeak(SymbolRef Sym, ExplodedNode *N,
   Optional<MallocChecker::CheckKind>
       CheckKind = getCheckIfTracked(Family, true);
 
   if (!CheckKind.hasValue())
     return;
 
   assert(N);
   if (!BT_Leak[*CheckKind]) {
-    BT_Leak[*CheckKind].reset(
-        new BugType(CheckNames[*CheckKind], "Memory leak", "Memory Error"));
+    BT_Leak[*CheckKind].reset(new BugType(CheckNames[*CheckKind], "Memory leak",
+                                          categories::MemoryError));
     // Leaks should not be reported if they are post-dominated by a sink:
     // (1) Sinks are higher importance bugs.
     // (2) NoReturnFunctionChecker uses sink nodes to represent paths ending
     //     with __noreturn functions such as assert() or exit(). We choose not
     //     to report leaks on such paths.
     BT_Leak[*CheckKind]->setSuppressOnSink(true);
   }
 

cfe/trunk/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp

void reportBugIfInvariantHolds(StringRef Msg, ErrorKind Error,
                                  CheckerContext &C,
                                  const Stmt *ValueExpr = nullptr,
                                   bool SuppressPath = false) const;
 
   void reportBug(StringRef Msg, ErrorKind Error, ExplodedNode *N,
                  const MemRegion *Region, BugReporter &BR,
                  const Stmt *ValueExpr = nullptr) const {
     if (!BT)
-      BT.reset(new BugType(this, "Nullability", "Memory error"));
+      BT.reset(new BugType(this, "Nullability", categories::MemoryError));
 
     auto R = llvm::make_unique<BugReport>(*BT, Msg, N);
     if (Region) {
       R->markInteresting(Region);
       R->addVisitor(llvm::make_unique<NullabilityBugVisitor>(Region));
     }
     if (ValueExpr) {
       R->addRange(ValueExpr->getSourceRange());

cfe/trunk/lib/StaticAnalyzer/Checkers/ValistChecker.cpp

void ValistChecker::reportUninitializedAccess(const MemRegion *VAList,
                                               StringRef Msg,
                                               CheckerContext &C) const {
   if (!ChecksEnabled[CK_Uninitialized])
     return;
   if (ExplodedNode *N = C.generateErrorNode()) {
     if (!BT_uninitaccess)
       BT_uninitaccess.reset(new BugType(CheckNames[CK_Uninitialized],
                                         "Uninitialized va_list",
-                                        "Memory Error"));
+                                        categories::MemoryError));
     auto R = llvm::make_unique<BugReport>(*BT_uninitaccess, Msg, N);
     R->markInteresting(VAList);
     R->addVisitor(llvm::make_unique<ValistBugVisitor>(VAList));
     C.emitReport(std::move(R));
   }
 }
 
 void ValistChecker::reportLeakedVALists(const RegionVector &LeakedVALists,
                                         StringRef Msg1, StringRef Msg2,
                                         CheckerContext &C, ExplodedNode *N,
                                         bool ForceReport) const {
   if (!(ChecksEnabled[CK_Unterminated] ||
         (ChecksEnabled[CK_Uninitialized] && ForceReport)))
     return;
   for (auto Reg : LeakedVALists) {
     if (!BT_leakedvalist) {
       BT_leakedvalist.reset(new BugType(CheckNames[CK_Unterminated],
-                                        "Leaked va_list", "Memory Error"));
+                                        "Leaked va_list",
+                                        categories::MemoryError));
       BT_leakedvalist->setSuppressOnSink(true);
     }
 
     const ExplodedNode *StartNode = getStartCallSite(N, Reg);
     PathDiagnosticLocation LocUsedForUniqueing;
 
     if (const Stmt *StartCallStmt = PathDiagnosticLocation::getStmt(StartNode))
       LocUsedForUniqueing = PathDiagnosticLocation::createBegin(

cfe/trunk/lib/StaticAnalyzer/Core/CommonBugCategories.cpp

 
 // Common strings used for the "category" of many static analyzer issues.
 namespace clang { namespace ento { namespace categories {
 
 const char * const CoreFoundationObjectiveC = "Core Foundation/Objective-C";
 const char * const LogicError = "Logic error";
 const char * const MemoryCoreFoundationObjectiveC =
   "Memory (Core Foundation/Objective-C)";
+const char * const MemoryError = "Memory error";
 const char * const UnixAPI = "Unix API";
 }}}

cfe/trunk/test/Analysis/MismatchedDeallocator-path-notes.cpp

 // CHECK-NEXT:     <key>depth</key><integer>0</integer>
 // CHECK-NEXT:     <key>extended_message</key>
 // CHECK-NEXT:     <string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string>
 // CHECK-NEXT:     <key>message</key>
 // CHECK-NEXT:     <string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string>
 // CHECK-NEXT:    </dict>
 // CHECK-NEXT:   </array>
 // CHECK-NEXT:   <key>description</key><string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string>
-// CHECK-NEXT:   <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:   <key>category</key><string>Memory error</string>
 // CHECK-NEXT:   <key>type</key><string>Bad deallocator</string>
 // CHECK-NEXT:   <key>check_name</key><string>unix.MismatchedDeallocator</string>
 // CHECK-NEXT:   <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:   <key>issue_hash_content_of_line_in_context</key><string>2009ca1da75217064b6052ba7465dff9</string>
 // CHECK-NEXT:  <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:  <key>issue_context</key><string>test</string>
 // CHECK-NEXT:  <key>issue_hash_function_offset</key><string>4</string>
 // CHECK-NEXT:  <key>location</key>
 // CHECK-NEXT:  <dict>
 // CHECK-NEXT:   <key>line</key><integer>13</integer>
 // CHECK-NEXT:   <key>col</key><integer>3</integer>
 // CHECK-NEXT:   <key>file</key><integer>0</integer>
 // CHECK-NEXT:  </dict>
 // CHECK-NEXT:  </dict>
 // CHECK-NEXT: </array>

cfe/trunk/test/Analysis/NewDelete-path-notes.cpp

 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
 // CHECK-NEXT:      <string>Attempt to free released memory</string>
 // CHECK-NEXT:      <key>message</key>
 // CHECK-NEXT:      <string>Attempt to free released memory</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
 // CHECK-NEXT:    <key>description</key><string>Attempt to free released memory</string>
-// CHECK-NEXT:    <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:    <key>category</key><string>Memory error</string>
 // CHECK-NEXT:    <key>type</key><string>Double free</string>
 // CHECK-NEXT:    <key>check_name</key><string>cplusplus.NewDelete</string>
 // CHECK-NEXT:    <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:    <key>issue_hash_content_of_line_in_context</key><string>bd8e324d09c70b9e2be6f824a4942e5a</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:   <key>issue_context</key><string>test</string>
 // CHECK-NEXT:   <key>issue_hash_function_offset</key><string>8</string>
 // CHECK-NEXT:   <key>location</key>

 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
 // CHECK-NEXT:      <string>Attempt to free released memory</string>
 // CHECK-NEXT:      <key>message</key>
 // CHECK-NEXT:      <string>Attempt to free released memory</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
 // CHECK-NEXT:    <key>description</key><string>Attempt to free released memory</string>
-// CHECK-NEXT:    <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:    <key>category</key><string>Memory error</string>
 // CHECK-NEXT:    <key>type</key><string>Double free</string>
 // CHECK-NEXT:    <key>check_name</key><string>cplusplus.NewDelete</string>
 // CHECK-NEXT:    <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:    <key>issue_hash_content_of_line_in_context</key><string>8bf1a5b9fdae9d86780aa6c4cdce2605</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:   <key>issue_context</key><string>test</string>
 // CHECK-NEXT:   <key>issue_hash_function_offset</key><string>3</string>
 // CHECK-NEXT:   <key>location</key>
 // CHECK-NEXT:   <dict>
 // CHECK-NEXT:    <key>line</key><integer>26</integer>
 // CHECK-NEXT:    <key>col</key><integer>2</integer>
 // CHECK-NEXT:    <key>file</key><integer>0</integer>
 // CHECK-NEXT:   </dict>
 // CHECK-NEXT:   </dict>
 // CHECK-NEXT:  </array>

cfe/trunk/test/Analysis/diagnostics/report-issues-within-main-file.cpp

 // CHECK-NEXT:     <key>depth</key><integer>1</integer>
 // CHECK-NEXT:     <key>extended_message</key>
 // CHECK-NEXT:     <string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string>
 // CHECK-NEXT:     <key>message</key>
 // CHECK-NEXT:     <string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string>
 // CHECK-NEXT:    </dict>
 // CHECK-NEXT:   </array>
 // CHECK-NEXT:   <key>description</key><string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos; (within a call to &apos;~auto_ptr&apos;)</string>
-// CHECK-NEXT:   <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:   <key>category</key><string>Memory error</string>
 // CHECK-NEXT:   <key>type</key><string>Bad deallocator</string>
 // CHECK-NEXT:   <key>check_name</key><string>unix.MismatchedDeallocator</string>
 // CHECK-NEXT:   <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:   <key>issue_hash_content_of_line_in_context</key><string>f689fbd54138491e228f0f89bb02bfb2</string>
 // CHECK-NEXT:  <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:  <key>issue_context</key><string>mainPlusHeader</string>
 // CHECK-NEXT:  <key>issue_hash_function_offset</key><string>2</string>
 // CHECK-NEXT:  <key>location</key>

cfe/trunk/test/Analysis/edges-new.mm

 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
 // CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:      <key>message</key>
 // CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
 // CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
-// CHECK-NEXT:    <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:    <key>category</key><string>Memory error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:    <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:    <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:    <key>issue_hash_content_of_line_in_context</key><string>51180616cd69dc1776be708299ec90fb</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:   <key>issue_context</key><string>reallocDiagnostics</string>
 // CHECK-NEXT:   <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:   <key>location</key>

 // CHECK-NEXT:      <key>depth</key><integer>1</integer>
 // CHECK-NEXT:      <key>extended_message</key>
 // CHECK-NEXT:      <string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string>
 // CHECK-NEXT:      <key>message</key>
 // CHECK-NEXT:      <string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
 // CHECK-NEXT:    <key>description</key><string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string>
-// CHECK-NEXT:    <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:    <key>category</key><string>Memory error</string>
 // CHECK-NEXT:    <key>type</key><string>Bad deallocator</string>
 // CHECK-NEXT:    <key>check_name</key><string>unix.MismatchedDeallocator</string>
 // CHECK-NEXT:    <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:    <key>issue_hash_content_of_line_in_context</key><string>d9dbbf68db41ab74e2158f4b131abe34</string>
 // CHECK-NEXT:   <key>issue_hash_function_offset</key><string>0</string>
 // CHECK-NEXT:   <key>location</key>
 // CHECK-NEXT:   <dict>
 // CHECK-NEXT:    <key>line</key><integer>544</integer>

cfe/trunk/test/Analysis/malloc-plist.c

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;p&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;p&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;p&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>c60b35a3e46fd104f362f430a1eaca5d</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>diagnosticTest</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>2</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;A&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;A&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;A&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>9b732ec46c4a08108dfbd37aa0955c51</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>myArrayAllocation</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>2</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>37c0b1a1e65d26af6f9fb840cf159149</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>reallocDiagnostics</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>384d1700f3d9c8eeea96d171e3030bdf</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>test_wrapper</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Use of memory after it is freed</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Use of memory after it is freed</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Use of memory after it is freed</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Use-after-free</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>422436dc85b85cde7e15046a5616ee99</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>test_double_action_call</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>3</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>23a6c295a515c455bea1c81519bc05b6</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>reallocIntra</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;v&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;v&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;v&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>45181c7fc1df81a732346f1ed1b3f238</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>use_ret</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>2</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Use of memory after it is freed</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Use of memory after it is freed</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Use of memory after it is freed</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Use-after-free</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>652c97005df876a65d64ecd286d6030a</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>call_myfree_takingblock</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>5</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;m&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;m&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;m&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>d8483ccf1d5a1af1e8bcaac6905a18b3</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>LeakedSymbol</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>3</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>1</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>b07aebe89e4ba5ea104a9f957df9531b</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>function_with_leak1</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>1</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>efe2ffcb7c227e872aa732c5f793895d</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>function_with_leak2</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>1</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>0ddc87e8a7e7104428af3905f3057611</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>function_with_leak3</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>1</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>948d356840e67fc4baa8cc5d0600463c</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>function_with_leak4</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>1</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>2b0361060027060b94915ff4de8aa782</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>function_with_leak5</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>1</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>73f573faa903ad4308d5155ef979cf31</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>function_with_leak6</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential memory leak</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential memory leak</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential memory leak</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>eb5628850b9b9118fbda903e721436a5</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>use_function_with_leak7</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential memory leak</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential memory leak</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential memory leak</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>ad5b603037bc3581ff94947e86dbb1c8</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>testOnlyRefferToVisibleVariables</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

 // CHECK-NEXT:       <key>depth</key><integer>0</integer>
 // CHECK-NEXT:       <key>extended_message</key>
 // CHECK-NEXT:       <string>Potential memory leak</string>
 // CHECK-NEXT:       <key>message</key>
 // CHECK-NEXT:       <string>Potential memory leak</string>
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:     </array>
 // CHECK-NEXT:     <key>description</key><string>Potential memory leak</string>
-// CHECK-NEXT:     <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:     <key>category</key><string>Memory error</string>
 // CHECK-NEXT:     <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:     <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:     <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:     <key>issue_hash_content_of_line_in_context</key><string>8d59cc5cc4b7db55d432abc18b0e6c23</string>
 // CHECK-NEXT:    <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:    <key>issue_context</key><string>testMyMalloc</string>
 // CHECK-NEXT:    <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:    <key>location</key>

cfe/trunk/test/Analysis/plist-macros.cpp

 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
 // CHECK-NEXT:      <string>Memory allocated by malloc() should be deallocated by free(), not &apos;delete&apos;</string>
 // CHECK-NEXT:      <key>message</key>
 // CHECK-NEXT:      <string>Memory allocated by malloc() should be deallocated by free(), not &apos;delete&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
 // CHECK-NEXT:    <key>description</key><string>Memory allocated by malloc() should be deallocated by free(), not &apos;delete&apos;</string>
-// CHECK-NEXT:    <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:    <key>category</key><string>Memory error</string>
 // CHECK-NEXT:    <key>type</key><string>Bad deallocator</string>
 // CHECK-NEXT:    <key>check_name</key><string>unix.MismatchedDeallocator</string>
 // CHECK-NEXT:    <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:    <key>issue_hash_content_of_line_in_context</key><string>81d63a132b4ef0cc96734c17440a1c26</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:   <key>issue_context</key><string>noteOnMacro</string>
 // CHECK-NEXT:   <key>issue_hash_function_offset</key><string>6</string>
 // CHECK-NEXT:   <key>location</key>

 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
 // CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      <key>message</key>
 // CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
 // CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
-// CHECK-NEXT:    <key>category</key><string>Memory Error</string>
+// CHECK-NEXT:    <key>category</key><string>Memory error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:    <key>check_name</key><string>unix.Malloc</string>
 // CHECK-NEXT:    <!-- This hash is experimental and going to change! -->
 // CHECK-NEXT:    <key>issue_hash_content_of_line_in_context</key><string>2d723d9fb4e5f10dd54a7396866dfce4</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
 // CHECK-NEXT:   <key>issue_context</key><string>macroIsFirstInFunction</string>
 // CHECK-NEXT:   <key>issue_hash_function_offset</key><string>1</string>
 // CHECK-NEXT:   <key>location</key>