Fixed compilation errors in tests, enforce checking for errors in check_clang_tidy_fix.sh.

[djasper]

Looks good.

test/clang-tidy/check_clang_tidy_fix.sh

 clang-tidy ${TEMPORARY_FILE} -fix --checks="-*,${CHECK_TO_RUN}" -- --std=c++11 \
   > ${TEMPORARY_FILE}.msg 2>&1
 
 FileCheck -input-file=${TEMPORARY_FILE} ${INPUT_FILE} \
   -check-prefix=CHECK-FIXES -strict-whitespace || exit $?
 
 if grep -q CHECK-MESSAGES ${INPUT_FILE}; then
   FileCheck -input-file=${TEMPORARY_FILE}.msg ${INPUT_FILE} \
-    -check-prefix=CHECK-MESSAGES -implicit-check-not="warning:" || exit $?
+    -check-prefix=CHECK-MESSAGES -implicit-check-not="{{warning|error}}:" \
+    || exit $?
 fi

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

 // RUN: $(dirname %s)/check_clang_tidy_fix.sh %s misc-redundant-smartptr-get %t
 // REQUIRES: shell
 
+#define NULL __null
+
 namespace std {
 
 template <typename T>
-class unique_ptr {
+struct unique_ptr {
   T& operator*() const;
   T* operator->() const;
   T* get() const;
 };
 
 template <typename T>
-class shared_ptr {
+struct shared_ptr {
   T& operator*() const;
   T* operator->() const;
   T* get() const;
 };
 
 }  // namespace std
 
 struct Bar {

test/clang-tidy/use-override.cpp

public:
 
   virtual void m() override final;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Use exactly
   // CHECK-FIXES: {{^  void m\(\) final;}}
 };
 
 // CHECK-MESSAGES-NOT: warning:
 
-void SimpleCases::i() {}
-// CHECK-FIXES: {{^void SimpleCases::i\(\) {}}}
+void SimpleCases::c() {}
+// CHECK-FIXES: {{^void SimpleCases::c\(\) {}}}
 
 SimpleCases::~SimpleCases() {}
 // CHECK-FIXES: {{^SimpleCases::~SimpleCases\(\) {}}}
 
 struct DefaultedDestructor : public Base {
   DefaultedDestructor() {}
   virtual ~DefaultedDestructor() = default;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: Prefer using
struct Macros : public Base {
   NOT_VIRTUAL void c() OVERRIDE;
   // CHECK-MESSAGES-NOT: warning:
   // CHECK-FIXES: {{^  NOT_VIRTUAL void c\(\) OVERRIDE;}}
 
   VIRTUAL void d() OVERRIDE;
   // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: Use exactly
   // CHECK-FIXES: {{^  VIRTUAL void d\(\) OVERRIDE;}}
 
-#define FUNC(name, return_type) return_type name()
+#define FUNC(return_type, name) return_type name()
   FUNC(void, e);
   // CHECK-FIXES: {{^  FUNC\(void, e\);}}
 
 #define F virtual void f();
   F
   // CHECK-FIXES: {{^  F}}
 
   VIRTUAL void g() OVERRIDE final;

 template <class C>
 struct UnusedMemberInstantiation : public C {
   virtual ~UnusedMemberInstantiation() {}
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: Prefer using
   // CHECK-FIXES: {{^  ~UnusedMemberInstantiation\(\) override {}}}
 };
 struct IntantiateWithoutUse : public UnusedMemberInstantiation<Base> {};
 
+struct Base2 {
+  virtual ~Base2() {}
+  virtual void a();
+};
+
 // The OverrideAttr isn't propagated to specializations in all cases. Make sure
 // we don't add "override" a second time.
 template <int I>
-struct MembersOfSpecializations : public Base {
+struct MembersOfSpecializations : public Base2 {
   void a() override;
   // CHECK-MESSAGES-NOT: warning:
   // CHECK-FIXES: {{^  void a\(\) override;}}
 };
 template <> void MembersOfSpecializations<3>::a() {}
-void f() { MembersOfSpecializations<3>().a(); };
+void ff() { MembersOfSpecializations<3>().a(); };