Thread safety: small formatting change in test comments

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@139306 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 225 insertions, 226 deletions

diff --git a/test/SemaCXX/warn-thread-safety-analysis.cpp b/test/SemaCXX/warn-thread-safety-analysis.cpp
index 6483a90a3c..4990627728 100644
--- a/test/SemaCXX/warn-thread-safety-analysis.cpp
+++ b/test/SemaCXX/warn-thread-safety-analysis.cpp
@@ -39,7 +39,6 @@ void sls_fun_0() {
   sls_mw.mu.Unlock();
 }
 
-
 void sls_fun_2() {
   sls_mu.Lock();
   int x = sls_guard_var;
@@ -124,33 +123,33 @@ void sls_fun_good_7() {
 
 void sls_fun_bad_1() {
   sls_mu.Unlock(); // \
-    expected-warning {{unlocking 'sls_mu' that was not acquired}}
+    // expected-warning{{unlocking 'sls_mu' that was not acquired}}
 }
 
 void sls_fun_bad_2() {
   sls_mu.Lock();
   sls_mu.Lock(); // \
-    expected-warning {{locking 'sls_mu' that is already acquired}}
+    // expected-warning{{locking 'sls_mu' that is already acquired}}
   sls_mu.Unlock();
 }
 
 void sls_fun_bad_3() {
   sls_mu.Lock(); // \
-    expected-warning {{lock 'sls_mu' is not released at the end of function 'sls_fun_bad_3'}}
+    // expected-warning{{lock 'sls_mu' is not released at the end of function 'sls_fun_bad_3'}}
 }
 
 void sls_fun_bad_4() {
   if (getBool())
     sls_mu.Lock(); // \
-      expected-warning {{lock 'sls_mu' is not released at the end of its scope}}
+      // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
   else
     sls_mu2.Lock(); // \
-      expected-warning {{lock 'sls_mu2' is not released at the end of its scope}}
+      // expected-warning{{lock 'sls_mu2' is not released at the end of its scope}}
 }
 
 void sls_fun_bad_5() {
   sls_mu.Lock(); // \
-    expected-warning {{lock 'sls_mu' is not released at the end of its scope}}
+    // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
   if (getBool())
     sls_mu.Unlock();
 }
@@ -158,7 +157,7 @@ void sls_fun_bad_5() {
 void sls_fun_bad_6() {
   if (getBool()) {
     sls_mu.Lock(); // \
-      expected-warning {{lock 'sls_mu' is not released at the end of its scope}}
+      // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
   } else {
     if (getBool()) {
       getBool(); // EMPTY
@@ -167,13 +166,13 @@ void sls_fun_bad_6() {
     }
   }
   sls_mu.Unlock(); // \
-    expected-warning {{unlocking 'sls_mu' that was not acquired}}
+    // expected-warning{{unlocking 'sls_mu' that was not acquired}}
 }
 
 void sls_fun_bad_7() {
   sls_mu.Lock();
   while (getBool()) { // \
-      expected-warning {{expecting lock 'sls_mu' to be held at start of each loop}}
+      // expected-warning{{expecting lock 'sls_mu' to be held at start of each loop}}
     sls_mu.Unlock();
     if (getBool()) {
       if (getBool()) {
@@ -181,7 +180,7 @@ void sls_fun_bad_7() {
       }
     }
     sls_mu.Lock(); // \
-      expected-warning {{lock 'sls_mu' is not released at the end of its scope}}
+      // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
   }
   sls_mu.Unlock();
 }
@@ -190,23 +189,23 @@ void sls_fun_bad_8() {
   sls_mu.Lock();
   do {
     sls_mu.Unlock();  // \
-      expected-warning {{expecting lock 'sls_mu' to be held at start of each loop}}
+      // expected-warning{{expecting lock 'sls_mu' to be held at start of each loop}}
   } while (getBool());
 }
 
 void sls_fun_bad_9() {
   do {
     sls_mu.Lock(); // \
-      expected-warning {{lock 'sls_mu' is not released at the end of its scope}}
+      // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
   } while (getBool());
   sls_mu.Unlock();
 }
 
 void sls_fun_bad_10() {
   sls_mu.Lock(); // \
-    expected-warning {{lock 'sls_mu' is not released at the end of function 'sls_fun_bad_10'}}
+    // expected-warning{{lock 'sls_mu' is not released at the end of function 'sls_fun_bad_10'}}
   while(getBool()) { // \
-      expected-warning {{expecting lock 'sls_mu' to be held at start of each loop}}
+      // expected-warning{{expecting lock 'sls_mu' to be held at start of each loop}}
     sls_mu.Unlock();
   }
 }
@@ -214,10 +213,10 @@ void sls_fun_bad_10() {
 void sls_fun_bad_11() {
   while (getBool()) {
     sls_mu.Lock(); // \
-      expected-warning {{lock 'sls_mu' is not released at the end of its scope}}
+      // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
   }
   sls_mu.Unlock(); // \
-    expected-warning {{unlocking 'sls_mu' that was not acquired}}
+    // expected-warning{{unlocking 'sls_mu' that was not acquired}}
 }
 
 
@@ -251,19 +250,19 @@ void aa_fun_2() {
 
 void aa_fun_bad_1() {
   glock.globalUnlock(); // \
-    expected-warning {{unlocking 'aa_mu' that was not acquired}}
+    // expected-warning{{unlocking 'aa_mu' that was not acquired}}
 }
 
 void aa_fun_bad_2() {
   glock.globalLock();
   glock.globalLock(); // \
-    expected-warning {{locking 'aa_mu' that is already acquired}}
+    // expected-warning{{locking 'aa_mu' that is already acquired}}
   glock.globalUnlock();
 }
 
 void aa_fun_bad_3() {
   glock.globalLock(); // \
-    expected-warning {{lock 'aa_mu' is not released at the end of function 'aa_fun_bad_3'}}
+    // expected-warning{{lock 'aa_mu' is not released at the end of function 'aa_fun_bad_3'}}
 }
 
 //--------------------------------------------------//
@@ -276,19 +275,19 @@ Mutex wmu;
 class WeirdMethods {
   WeirdMethods() {
     wmu.Lock(); // \
-      expected-warning {{lock 'wmu' is not released at the end of function 'WeirdMethods'}}
+      // expected-warning {{lock 'wmu' is not released at the end of function 'WeirdMethods'}}
   }
   ~WeirdMethods() {
     wmu.Lock(); // \
-      expected-warning {{lock 'wmu' is not released at the end of function '~WeirdMethods'}}
+      // expected-warning {{lock 'wmu' is not released at the end of function '~WeirdMethods'}}
   }
   void operator++() {
     wmu.Lock(); // \
-      expected-warning {{lock 'wmu' is not released at the end of function 'operator++'}}
+      // expected-warning {{lock 'wmu' is not released at the end of function 'operator++'}}
   }
   operator int*() {
     wmu.Lock(); // \
-      expected-warning {{lock 'wmu' is not released at the end of function 'operator int *'}}
+      // expected-warning {{lock 'wmu' is not released at the end of function 'operator int *'}}
     return 0;
   }
 };
@@ -307,13 +306,13 @@ class PGBFoo {
                  __attribute__((pt_guarded_by(sls_mu)));
   void testFoo() {
     pgb_field = &x; // \
-      expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}}
+      // expected-warning{{accessing variable 'pgb_field' requires lock 'sls_mu2'}}
     *pgb_field = x; // expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}} \
-      expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}}
+      // expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}}
     x = *pgb_field; // expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}} \
-      expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}}
+      // expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}}
     (*pgb_field)++; // expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}} \
-      expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}}
+      // expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}}
   }
 };
 
@@ -323,7 +322,7 @@ class GBFoo {
 
   void testFoo() {
     gb_field = 0; // \
-      expected-warning {{accessing variable 'gb_field' requires lock 'sls_mu'}}
+      // expected-warning{{accessing variable 'gb_field' requires lock 'sls_mu'}}
   }
 };
 
@@ -352,59 +351,59 @@ void gb_fun_3() {
 
 void gb_bad_0() {
   sls_guard_var = 1; // \
-    expected-warning {{accessing variable 'sls_guard_var' requires some lock}}
+    // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
 }
 
 void gb_bad_1() {
   int x = sls_guard_var; // \
-    expected-warning {{accessing variable 'sls_guard_var' requires some lock}}
+    // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
 }
 
 void gb_bad_2() {
   sls_guardby_var = 1; // \
-    expected-warning {{accessing variable 'sls_guardby_var' requires lock 'sls_mu'}}
+    // expected-warning{{accessing variable 'sls_guardby_var' requires lock 'sls_mu'}}
 }
 
 void gb_bad_3() {
   int x = sls_guardby_var; // \
-    expected-warning {{accessing variable 'sls_guardby_var' requires lock 'sls_mu'}}
+    // expected-warning{{accessing variable 'sls_guardby_var' requires lock 'sls_mu'}}
 }
 
 void gb_bad_4() {
   *pgb_gvar = 1; // \
-    expected-warning {{accessing the value pointed to by 'pgb_gvar' requires some lock}}
+    // expected-warning {{accessing the value pointed to by 'pgb_gvar' requires some lock}}
 }
 
 void gb_bad_5() {
   int x = *pgb_gvar; // \
-    expected-warning {{accessing the value pointed to by 'pgb_gvar' requires some lock}}
+    // expected-warning {{accessing the value pointed to by 'pgb_gvar' requires some lock}}
 }
 
 void gb_bad_6() {
   *pgb_var = 1; // \
-    expected-warning {{accessing the value pointed to by 'pgb_var' requires lock 'sls_mu'}}
+    // expected-warning {{accessing the value pointed to by 'pgb_var' requires lock 'sls_mu'}}
 }
 
 void gb_bad_7() {
   int x = *pgb_var; // \
-    expected-warning {{accessing the value pointed to by 'pgb_var' requires lock 'sls_mu'}}
+    // expected-warning {{accessing the value pointed to by 'pgb_var' requires lock 'sls_mu'}}
 }
 
 void gb_bad_8() {
   GBFoo G;
   G.gb_field = 0; // \
-    expected-warning {{accessing variable 'gb_field' requires lock 'sls_mu'}}
+    // expected-warning{{accessing variable 'gb_field' requires lock 'sls_mu'}}
 }
 
 void gb_bad_9() {
   sls_guard_var++; // \
-    expected-warning {{accessing variable 'sls_guard_var' requires some lock}}
+    // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
   sls_guard_var--; // \
-    expected-warning {{accessing variable 'sls_guard_var' requires some lock}}
+    // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
   ++sls_guard_var; // \
-    expected-warning {{accessing variable 'sls_guard_var' requires some lock}}
+    // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
   --sls_guard_var; // \
-    expected-warning {{accessing variable 'sls_guard_var' requires some lock}}    
+    // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
 }
 
 //-----------------------------------------------//
@@ -420,11 +419,11 @@ public:
 
   void test() {
     a = 0; // \
-      expected-warning {{accessing variable 'a' requires lock 'mu'}}
+      // expected-warning{{accessing variable 'a' requires lock 'mu'}}
     b = a; // \
-      expected-warning {{accessing variable 'a' requires lock 'mu'}}
+      // expected-warning {{accessing variable 'a' requires lock 'mu'}}
     c = 0; // \
-      expected-warning {{accessing variable 'c' requires lock 'mu'}}
+      // expected-warning {{accessing variable 'c' requires lock 'mu'}}
   }
 
   int c __attribute__((guarded_by(mu)));
diff --git a/test/SemaCXX/warn-thread-safety-parsing.cpp b/test/SemaCXX/warn-thread-safety-parsing.cpp
index 8fcac408e3..67882d0899 100644
--- a/test/SemaCXX/warn-thread-safety-parsing.cpp
+++ b/test/SemaCXX/warn-thread-safety-parsing.cpp
@@ -76,32 +76,32 @@ class Bar {
 void noanal_fun() __attribute__((no_thread_safety_analysis));
 
 void noanal_fun_args() __attribute__((no_thread_safety_analysis(1))); // \
-  expected-error {{attribute takes no arguments}}
+  // expected-error {{attribute takes no arguments}}
 
 int noanal_testfn(int y) __attribute__((no_thread_safety_analysis));
 
 int noanal_testfn(int y) {
   int x __attribute__((no_thread_safety_analysis)) = y; // \
-    expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+    // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
   return x;
 };
 
 int noanal_test_var __attribute__((no_thread_safety_analysis)); // \
-  expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+  // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
 
 class NoanalFoo {
  private:
   int test_field __attribute__((no_thread_safety_analysis)); // \
-    expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+    // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
   void test_method() __attribute__((no_thread_safety_analysis));
 };
 
 class __attribute__((no_thread_safety_analysis)) NoanalTestClass { // \
-    expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+  // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
 };
 
 void noanal_fun_params(int lvar __attribute__((no_thread_safety_analysis))); // \
-  expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
+  // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
 
 
 //-----------------------------------------//
@@ -115,28 +115,28 @@ void noanal_fun_params(int lvar __attribute__((no_thread_safety_analysis))); //
 int gv_var_noargs __attribute__((guarded_var));
 
 int gv_var_args __attribute__((guarded_var(1))); // \
-    expected-error {{attribute takes no arguments}}
+  // expected-error {{attribute takes no arguments}}
 
 class GVFoo {
  private:
   int gv_field_noargs __attribute__((guarded_var));
   int gv_field_args __attribute__((guarded_var(1))); // \
-      expected-error {{attribute takes no arguments}}
+    // expected-error {{attribute takes no arguments}}
 };
 
 class __attribute__((guarded_var)) GV { // \
-      expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
+  // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
 };
 
 void gv_function() __attribute__((guarded_var)); // \
-    expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
+  // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
 
 void gv_function_params(int gv_lvar __attribute__((guarded_var))); // \
-    expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
+  // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
 
 int gv_testfn(int y){
   int x __attribute__((guarded_var)) = y; // \
-      expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
+    // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
   return x;
 }
 
@@ -153,34 +153,34 @@ int gv_testfn(int y){
 int *pgv_pt_var_noargs __attribute__((pt_guarded_var));
 
 int pgv_var_noargs __attribute__((pt_guarded_var)); // \
-    expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}}
+    // expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}}
 
 class PGVFoo {
  private:
   int *pt_field_noargs __attribute__((pt_guarded_var));
   int field_noargs __attribute__((pt_guarded_var)); // \
-    expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}}
+    // expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}}
   int *gv_field_args __attribute__((pt_guarded_var(1))); // \
-    expected-error {{attribute takes no arguments}}
+    // expected-error {{attribute takes no arguments}}
 };
 
 class __attribute__((pt_guarded_var)) PGV { // \
-    expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
+  // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
 };
 
 int *pgv_var_args __attribute__((pt_guarded_var(1))); // \
-  expected-error {{attribute takes no arguments}}
+  // expected-error {{attribute takes no arguments}}
 
 
 void pgv_function() __attribute__((pt_guarded_var)); // \
-  expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
+  // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
 
 void pgv_function_params(int *gv_lvar __attribute__((pt_guarded_var))); // \
-  expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
+  // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
 
 void pgv_testfn(int y){
   int *x __attribute__((pt_guarded_var)) = new int(0); // \
-    expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
+    // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
   delete x;
 }
 
@@ -198,32 +198,32 @@ class __attribute__((lockable)) LTestClass {
 };
 
 class __attribute__((lockable (1))) LTestClass_args { // \
-    expected-error {{attribute takes no arguments}}
+    // expected-error {{attribute takes no arguments}}
 };
 
 void l_test_function() __attribute__((lockable));  // \
-  expected-warning {{'lockable' attribute only applies to classes}}
+  // expected-warning {{'lockable' attribute only applies to classes}}
 
 int l_testfn(int y) {
   int x __attribute__((lockable)) = y; // \
-    expected-warning {{'lockable' attribute only applies to classes}}
+    // expected-warning {{'lockable' attribute only applies to classes}}
   return x;
 }
 
 int l_test_var __attribute__((lockable)); // \
-  expected-warning {{'lockable' attribute only applies to classes}}
+  // expected-warning {{'lockable' attribute only applies to classes}}
 
 class LFoo {
  private:
   int test_field __attribute__((lockable)); // \
-    expected-warning {{'lockable' attribute only applies to classes}}
+    // expected-warning {{'lockable' attribute only applies to classes}}
   void test_method() __attribute__((lockable)); // \
-    expected-warning {{'lockable' attribute only applies to classes}}
+    // expected-warning {{'lockable' attribute only applies to classes}}
 };
 
 
 void l_function_params(int lvar __attribute__((lockable))); // \
-  expected-warning {{'lockable' attribute only applies to classes}}
+  // expected-warning {{'lockable' attribute only applies to classes}}
 
 
 //-----------------------------------------//
@@ -238,32 +238,32 @@ class __attribute__((scoped_lockable)) SLTestClass {
 };
 
 class __attribute__((scoped_lockable (1))) SLTestClass_args { // \
-    expected-error {{attribute takes no arguments}}
+  // expected-error {{attribute takes no arguments}}
 };
 
 void sl_test_function() __attribute__((scoped_lockable));  // \
-  expected-warning {{'scoped_lockable' attribute only applies to classes}}
+  // expected-warning {{'scoped_lockable' attribute only applies to classes}}
 
 int sl_testfn(int y) {
   int x __attribute__((scoped_lockable)) = y; // \
-    expected-warning {{'scoped_lockable' attribute only applies to classes}}
+    // expected-warning {{'scoped_lockable' attribute only applies to classes}}
   return x;
 }
 
 int sl_test_var __attribute__((scoped_lockable)); // \
-  expected-warning {{'scoped_lockable' attribute only applies to classes}}
+  // expected-warning {{'scoped_lockable' attribute only applies to classes}}
 
 class SLFoo {
  private:
   int test_field __attribute__((scoped_lockable)); // \
-    expected-warning {{'scoped_lockable' attribute only applies to classes}}
+    // expected-warning {{'scoped_lockable' attribute only applies to classes}}
   void test_method() __attribute__((scoped_lockable)); // \
-    expected-warning {{'scoped_lockable' attribute only applies to classes}}
+    // expected-warning {{'scoped_lockable' attribute only applies to classes}}
 };
 
 
 void sl_function_params(int lvar __attribute__((scoped_lockable))); // \
-  expected-warning {{'scoped_lockable' attribute only applies to classes}}
+  // expected-warning {{'scoped_lockable' attribute only applies to classes}}
 
 
 //-----------------------------------------//
@@ -281,31 +281,31 @@ void sl_function_params(int lvar __attribute__((scoped_lockable))); // \
 int gb_var_arg __attribute__((guarded_by(mu1)));
 
 int gb_var_args __attribute__((guarded_by(mu1, mu2))); // \
-  expected-error {{attribute takes one argument}}
+  // expected-error {{attribute takes one argument}}
 
 int gb_var_noargs __attribute__((guarded_by)); // \
-  expected-error {{attribute takes one argument}}
+  // expected-error {{attribute takes one argument}}
 
 class GBFoo {
  private:
   int gb_field_noargs __attribute__((guarded_by)); // \
-    expected-error {{attribute takes one argument}}
+    // expected-error {{attribute takes one argument}}
   int gb_field_args __attribute__((guarded_by(mu1)));
 };
 
 class __attribute__((guarded_by(mu1))) GB { // \
-      expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
+  // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
 };
 
 void gb_function() __attribute__((guarded_by(mu1))); // \
-    expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
+  // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
 
 void gb_function_params(int gv_lvar __attribute__((guarded_by(mu1)))); // \
-    expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
+  // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
 
 int gb_testfn(int y){
   int x __attribute__((guarded_by(mu1))) = y; // \
-      expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
+    // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
   return x;
 }
 
@@ -324,13 +324,13 @@ int gb_var_arg_8 __attribute__((guarded_by(muPointer)));
 
 // illegal attribute arguments
 int gb_var_arg_bad_1 __attribute__((guarded_by(1))); // \
-  expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
 int gb_var_arg_bad_2 __attribute__((guarded_by("mu"))); // \
-  expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
 int gb_var_arg_bad_3 __attribute__((guarded_by(muDoublePointer))); // \
-  expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
 int gb_var_arg_bad_4 __attribute__((guarded_by(umu))); // \
-  expected-error {{'guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+  // expected-error {{'guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}}
 
 //3.
 // Thread Safety analysis tests
@@ -347,36 +347,36 @@ int gb_var_arg_bad_4 __attribute__((guarded_by(umu))); // \
 //1. Check applied to the right types & argument number
 
 int *pgb_var_noargs __attribute__((pt_guarded_by)); // \
-  expected-error {{attribute takes one argument}}
+  // expected-error {{attribute takes one argument}}
 
 int *pgb_ptr_var_arg __attribute__((pt_guarded_by(mu1)));
 
 int *pgb_ptr_var_args __attribute__((guarded_by(mu1, mu2))); // \
-  expected-error {{attribute takes one argument}}
+  // expected-error {{attribute takes one argument}}
 
 int pgb_var_args __attribute__((pt_guarded_by(mu1))); // \
-    expected-warning {{'pt_guarded_by' only applies to pointer types; type here is 'int'}}
+  // expected-warning {{'pt_guarded_by' only applies to pointer types; type here is 'int'}}
 
 class PGBFoo {
  private:
   int *pgb_field_noargs __attribute__((pt_guarded_by)); // \
-    expected-error {{attribute takes one argument}}
+    // expected-error {{attribute takes one argument}}
   int *pgb_field_args __attribute__((pt_guarded_by(mu1)));
 };
 
 class __attribute__((pt_guarded_by(mu1))) PGB { // \
-      expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
+  // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
 };
 
 void pgb_function() __attribute__((pt_guarded_by(mu1))); // \
-    expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
+  // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
 
 void pgb_function_params(int gv_lvar __attribute__((pt_guarded_by(mu1)))); // \
-    expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
+  // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
 
 void pgb_testfn(int y){
   int *x __attribute__((pt_guarded_by(mu1))) = new int(0); // \
-      expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
+    // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
   delete x;
 }
 
@@ -395,13 +395,13 @@ int * pgb_var_arg_8 __attribute__((pt_guarded_by(muPointer)));
 
 // illegal attribute arguments
 int * pgb_var_arg_bad_1 __attribute__((pt_guarded_by(1))); // \
-  expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
 int * pgb_var_arg_bad_2 __attribute__((pt_guarded_by("mu"))); // \
-  expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
 int * pgb_var_arg_bad_3 __attribute__((pt_guarded_by(muDoublePointer))); // \
-  expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
 int * pgb_var_arg_bad_4 __attribute__((pt_guarded_by(umu))); // \
-  expected-error {{'pt_guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+  // expected-error {{'pt_guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}}
 
 
 //-----------------------------------------//
@@ -417,28 +417,28 @@ int * pgb_var_arg_bad_4 __attribute__((pt_guarded_by(umu))); // \
 Mu mu_aa __attribute__((acquired_after(mu1)));
 
 Mu aa_var_noargs __attribute__((acquired_after)); // \
-  expected-error {{attribute takes at least 1 argument}}
+  // expected-error {{attribute takes at least 1 argument}}
 
 class AAFoo {
  private:
   Mu aa_field_noargs __attribute__((acquired_after)); // \
-    expected-error {{attribute takes at least 1 argument}}
+    // expected-error {{attribute takes at least 1 argument}}
   Mu aa_field_args __attribute__((acquired_after(mu1)));
 };
 
 class __attribute__((acquired_after(mu1))) AA { // \
-      expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
+  // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
 };
 
 void aa_function() __attribute__((acquired_after(mu1))); // \
-    expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
+  // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
 
 void aa_function_params(int gv_lvar __attribute__((acquired_after(mu1)))); // \
-    expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
+  // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
 
 void aa_testfn(int y){
   Mu x __attribute__((acquired_after(mu1))) = Mu(); // \
-      expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
+    // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
 }
 
 //Check argument parsing.
@@ -456,15 +456,15 @@ Mu aa_var_arg_8 __attribute__((acquired_after(muPointer)));
 
 // illegal attribute arguments
 Mu aa_var_arg_bad_1 __attribute__((acquired_after(1))); // \
-  expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
 Mu aa_var_arg_bad_2 __attribute__((acquired_after("mu"))); // \
-  expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
 Mu aa_var_arg_bad_3 __attribute__((acquired_after(muDoublePointer))); // \
-  expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
 Mu aa_var_arg_bad_4 __attribute__((acquired_after(umu))); // \
-  expected-error {{'acquired_after' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+  // expected-error {{'acquired_after' attribute requires arguments whose type is annotated with 'lockable' attribute}}
 UnlockableMu aa_var_arg_bad_5 __attribute__((acquired_after(mu_aa))); // \
-  expected-error {{'acquired_after' attribute can only be applied in a context annotated with 'lockable' attribute}}
+  // expected-error {{'acquired_after' attribute can only be applied in a context annotated with 'lockable' attribute}}
 
 //-----------------------------------------//
 //  Acquired Before (ab)
@@ -477,28 +477,28 @@ UnlockableMu aa_var_arg_bad_5 __attribute__((acquired_after(mu_aa))); // \
 Mu mu_ab __attribute__((acquired_before(mu1)));
 
 Mu ab_var_noargs __attribute__((acquired_before)); // \
-  expected-error {{attribute takes at least 1 argument}}
+  // expected-error {{attribute takes at least 1 argument}}
 
 class ABFoo {
  private:
   Mu ab_field_noargs __attribute__((acquired_before)); // \
-    expected-error {{attribute takes at least 1 argument}}
+    // expected-error {{attribute takes at least 1 argument}}
   Mu ab_field_args __attribute__((acquired_before(mu1)));
 };
 
 class __attribute__((acquired_before(mu1))) AB { // \
-      expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
+  // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
 };
 
 void ab_function() __attribute__((acquired_before(mu1))); // \
-    expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
+  // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
 
 void ab_function_params(int gv_lvar __attribute__((acquired_before(mu1)))); // \
-    expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
+  // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
 
 void ab_testfn(int y){
   Mu x __attribute__((acquired_before(mu1))) = Mu(); // \
-      expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
+    // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
 }
 
 // Note: illegal int ab_int __attribute__((acquired_before(mu1))) will
@@ -519,15 +519,15 @@ Mu ab_var_arg_8 __attribute__((acquired_before(muPointer)));
 
 // illegal attribute arguments
 Mu ab_var_arg_bad_1 __attribute__((acquired_before(1))); // \
-  expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
 Mu ab_var_arg_bad_2 __attribute__((acquired_before("mu"))); // \
-  expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
 Mu ab_var_arg_bad_3 __attribute__((acquired_before(muDoublePointer))); // \
-  expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
 Mu ab_var_arg_bad_4 __attribute__((acquired_before(umu))); // \
-  expected-error {{'acquired_before' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+  // expected-error {{'acquired_before' attribute requires arguments whose type is annotated with 'lockable' attribute}}
 UnlockableMu ab_var_arg_bad_5 __attribute__((acquired_before(mu_ab))); // \
-  expected-error {{'acquired_before' attribute can only be applied in a context annotated with 'lockable' attribute}}
+  // expected-error {{'acquired_before' attribute can only be applied in a context annotated with 'lockable' attribute}}
 
 
 //-----------------------------------------//
@@ -548,26 +548,26 @@ int elf_testfn(int y) __attribute__((exclusive_lock_function));
 
 int elf_testfn(int y) {
   int x __attribute__((exclusive_lock_function)) = y; // \
-    expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
+    // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
   return x;
 };
 
 int elf_test_var __attribute__((exclusive_lock_function)); // \
-  expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
+  // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
 
 class ElfFoo {
  private:
   int test_field __attribute__((exclusive_lock_function)); // \
-    expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
+    // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
   void test_method() __attribute__((exclusive_lock_function));
 };
 
 class __attribute__((exclusive_lock_function)) ElfTestClass { // \
-    expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
+  // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
 };
 
 void elf_fun_params(int lvar __attribute__((exclusive_lock_function))); // \
-  expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
+  // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
 
 // Check argument parsing.
 
@@ -586,20 +586,20 @@ int elf_function_9(Mu x, Mu y) __attribute__((exclusive_lock_function(1,2)));
 
 // illegal attribute arguments
 int elf_function_bad_2() __attribute__((exclusive_lock_function("mu"))); // \
-  expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}}
 int elf_function_bad_3() __attribute__((exclusive_lock_function(muDoublePointer))); // \
-  expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}}
 int elf_function_bad_4() __attribute__((exclusive_lock_function(umu))); // \
-  expected-error {{'exclusive_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
+  // expected-error {{'exclusive_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
 
 int elf_function_bad_1() __attribute__((exclusive_lock_function(1))); // \
-  expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
+  // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
 int elf_function_bad_5(Mu x) __attribute__((exclusive_lock_function(0))); // \
-  expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
+  // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
 int elf_function_bad_6(Mu x, Mu y) __attribute__((exclusive_lock_function(0))); // \
-  expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
+  // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
 int elf_function_bad_7() __attribute__((exclusive_lock_function(0))); // \
-  expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
+  // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
 
 
 //-----------------------------------------//
@@ -620,25 +620,25 @@ int slf_testfn(int y) __attribute__((shared_lock_function));
 
 int slf_testfn(int y) {
   int x __attribute__((shared_lock_function)) = y; // \
-    expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
+    // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
   return x;
 };
 
 int slf_test_var __attribute__((shared_lock_function)); // \
-  expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
+  // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
 
 void slf_fun_params(int lvar __attribute__((shared_lock_function))); // \
-  expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
+  // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
 
 class SlfFoo {
  private:
   int test_field __attribute__((shared_lock_function)); // \
-    expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
+    // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
   void test_method() __attribute__((shared_lock_function));
 };
 
 class __attribute__((shared_lock_function)) SlfTestClass { // \
-    expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
+  // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
 };
 
 // Check argument parsing.
@@ -658,20 +658,20 @@ int slf_function_9(Mu x, Mu y) __attribute__((shared_lock_function(1,2)));
 
 // illegal attribute arguments
 int slf_function_bad_2() __attribute__((shared_lock_function("mu"))); // \
-  expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}}
 int slf_function_bad_3() __attribute__((shared_lock_function(muDoublePointer))); // \
-  expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}}
+  // expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}}
 int slf_function_bad_4() __attribute__((shared_lock_function(umu))); // \
-  expected-error {{'shared_lock_function' attribute requires