[undo] Fixed CLang incompatibility

[libcds.git] / test / unit / misc / cxx11_atomic_func.cpp

diff --git a/test/unit/misc/cxx11_atomic_func.cpp b/test/unit/misc/cxx11_atomic_func.cpp
index 2ed477d7fe22e8d5549768c6e80dbae90e3ae241..55e61ab62a48788d515ad2ef79d9a57073171a76 100644 (file)
--- a/test/unit/misc/cxx11_atomic_func.cpp
+++ b/test/unit/misc/cxx11_atomic_func.cpp
@@ -1,7 +1,7 @@
 /*
     This file is a part of libcds - Concurrent Data Structures library
 
-    (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
+    (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2017
 
     Source code repo: http://github.com/khizmax/libcds/
     Download: http://sourceforge.net/projects/libcds/files/
@@ -37,6 +37,8 @@
 
 #include "cxx11_convert_memory_order.h"
 
+#define EXPECT_ATOMIC_IS_LOCK_FREE( x ) EXPECT_TRUE( atomics::atomic_is_lock_free( &x ));
+
 namespace misc {
 
     class cxx11_atomic_func: public ::testing::Test
@@ -81,13 +83,12 @@ namespace misc {
         {
             typedef Integral    integral_type;
 
-            EXPECT_TRUE( atomics::atomic_is_lock_free( &a ));
+            EXPECT_ATOMIC_IS_LOCK_FREE( a );
             atomics::atomic_store( &a, (integral_type) 0 );
-            //EXPECT_EQ( a, integral_type( 0 ));
             EXPECT_EQ( atomics::atomic_load( &a ), integral_type( 0 ));
 
             for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) {
-                integral_type n = integral_type(42) << (nByte * 8);
+                integral_type n = static_cast<integral_type>( integral_type(42) << (nByte * 8));
                 EXPECT_EQ( atomics::atomic_exchange( &a, n ), (integral_type) 0 );
                 EXPECT_EQ( atomics::atomic_load( &a ), n );
                 EXPECT_EQ( atomics::atomic_exchange( &a, (integral_type) 0 ), n );
@@ -96,7 +97,7 @@ namespace misc {
 
             integral_type prev = atomics::atomic_load( &a );
             for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) {
-                integral_type n = integral_type(42) << (nByte * 8);
+                integral_type n = static_cast<integral_type>( integral_type(42) << (nByte * 8));
                 integral_type expected = prev;
 
                 EXPECT_TRUE( atomics::atomic_compare_exchange_weak( &a, &expected, n));
@@ -113,7 +114,7 @@ namespace misc {
 
             prev = atomics::atomic_load( &a );
             for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) {
-                integral_type n = integral_type(42) << (nByte * 8);
+                integral_type n = static_cast<integral_type>( integral_type(42) << (nByte * 8));
                 integral_type expected = prev;
 
                 EXPECT_TRUE( atomics::atomic_compare_exchange_strong( &a, &expected, n));
@@ -142,7 +143,7 @@ namespace misc {
             for ( size_t nByte = 0; nByte < sizeof(integral_type); ++nByte )
             {
                 integral_type prev = atomics::atomic_load( &a );
-                integral_type n = integral_type(42) << (nByte * 8);
+                integral_type n = static_cast<integral_type>( integral_type(42) << (nByte * 8));
 
                 EXPECT_EQ( atomics::atomic_fetch_add( &a, n ), prev );
             }
@@ -151,7 +152,7 @@ namespace misc {
             for ( size_t nByte = sizeof(integral_type); nByte > 0; --nByte )
             {
                 integral_type prev = atomics::atomic_load( &a );
-                integral_type n = integral_type(42) << ((nByte - 1) * 8);
+                integral_type n = static_cast<integral_type>( integral_type(42) << ((nByte - 1) * 8));
 
                 EXPECT_EQ( atomics::atomic_fetch_sub( &a, n ), prev );
             }
@@ -161,7 +162,7 @@ namespace misc {
             for ( size_t nBit = 0; nBit < sizeof(integral_type) * 8; ++nBit )
             {
                 integral_type prev = atomics::atomic_load( &a );
-                integral_type mask = integral_type(1) << nBit;
+                integral_type mask = static_cast<integral_type>( integral_type(1) << nBit );
 
                 EXPECT_EQ( atomics::atomic_fetch_or( &a, mask ), prev );
                 prev = atomics::atomic_load( &a );
@@ -186,13 +187,12 @@ namespace misc {
             const atomics::memory_order oLoad = convert_to_load_order( order );
             const atomics::memory_order oStore = convert_to_store_order( order );
 
-            EXPECT_TRUE( atomics::atomic_is_lock_free( &a ));
+            EXPECT_ATOMIC_IS_LOCK_FREE( a );
             atomics::atomic_store_explicit( &a, (integral_type) 0, oStore );
-            //EXPECT_EQ( a, integral_type( 0 ));
             EXPECT_EQ( atomics::atomic_load_explicit( &a, oLoad ), (integral_type) 0 );
 
             for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) {
-                integral_type n = integral_type(42) << (nByte * 8);
+                integral_type n = static_cast<integral_type>( integral_type(42) << (nByte * 8));
                 EXPECT_EQ( atomics::atomic_exchange_explicit( &a, n, order ), (integral_type) 0 );
                 EXPECT_EQ( atomics::atomic_load_explicit( &a, oLoad ), n );
                 EXPECT_EQ( atomics::atomic_exchange_explicit( &a, (integral_type) 0, order ), n );
@@ -201,7 +201,7 @@ namespace misc {
 
             integral_type prev = atomics::atomic_load_explicit( &a, oLoad );
             for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) {
-                integral_type n = integral_type(42) << (nByte * 8);
+                integral_type n = static_cast<integral_type>( integral_type(42) << (nByte * 8));
                 integral_type expected = prev;
 
                 EXPECT_TRUE( atomics::atomic_compare_exchange_weak_explicit( &a, &expected, n, order, atomics::memory_order_relaxed));
@@ -217,7 +217,7 @@ namespace misc {
 
             prev = atomics::atomic_load_explicit( &a, oLoad );
             for ( size_t nByte = 0; nByte < sizeof(Integral); ++nByte ) {
-                integral_type n = integral_type(42) << (nByte * 8);
+                integral_type n = static_cast<integral_type>( integral_type(42) << (nByte * 8));
                 integral_type expected = prev;
 
                 EXPECT_TRUE( atomics::atomic_compare_exchange_strong_explicit( &a, &expected, n, order, atomics::memory_order_relaxed));
@@ -248,7 +248,7 @@ namespace misc {
             for ( size_t nByte = 0; nByte < sizeof(integral_type); ++nByte )
             {
                 integral_type prev = atomics::atomic_load_explicit( &a, oLoad );
-                integral_type n = integral_type(42) << (nByte * 8);
+                integral_type n = static_cast<integral_type>( integral_type(42) << (nByte * 8));
 
                 EXPECT_EQ( atomics::atomic_fetch_add_explicit( &a, n, order), prev);
             }
@@ -257,7 +257,7 @@ namespace misc {
             for ( size_t nByte = sizeof(integral_type); nByte > 0; --nByte )
             {
                 integral_type prev = atomics::atomic_load_explicit( &a, oLoad );
-                integral_type n = integral_type(42) << ((nByte - 1) * 8);
+                integral_type n = static_cast<integral_type>( integral_type(42) << ((nByte - 1) * 8));
 
                 EXPECT_EQ( atomics::atomic_fetch_sub_explicit( &a, n, order ), prev);
             }
@@ -267,7 +267,7 @@ namespace misc {
             for ( size_t nBit = 0; nBit < sizeof(integral_type) * 8; ++nBit )
             {
                 integral_type prev = atomics::atomic_load_explicit( &a, oLoad )  ;;
-                integral_type mask = integral_type(1) << nBit;
+                integral_type mask = static_cast<integral_type>( integral_type(1) << nBit );
 
                 EXPECT_EQ( atomics::atomic_fetch_or_explicit( &a, mask, order ), prev );
                 prev = atomics::atomic_load_explicit( &a, oLoad );
@@ -318,7 +318,7 @@ namespace misc {
         template <class AtomicBool>
         void do_test_atomic_bool(AtomicBool& a)
         {
-            EXPECT_TRUE( atomics::atomic_is_lock_free( &a ));
+            EXPECT_ATOMIC_IS_LOCK_FREE( a );
             atomics::atomic_store( &a, false );
             EXPECT_FALSE( a );
             EXPECT_FALSE( atomics::atomic_load( &a ));
@@ -355,7 +355,7 @@ namespace misc {
             const atomics::memory_order oStore = convert_to_store_order( order );
             const atomics::memory_order oExchange = convert_to_exchange_order( order );
 
-            EXPECT_TRUE( atomics::atomic_is_lock_free( &a ));
+            EXPECT_ATOMIC_IS_LOCK_FREE( a );
             atomics::atomic_store_explicit( &a, false, oStore );
             EXPECT_FALSE( a == false );
             EXPECT_FALSE( atomics::atomic_load_explicit( &a, oLoad ));
@@ -439,7 +439,7 @@ namespace misc {
             integral_type   arr[8];
             const integral_type aSize = sizeof(arr)/sizeof(arr[0]);
             for ( integral_type i = 0; i < aSize; ++i ) {
-                arr[size_t(i)] = i + 1;
+                arr[static_cast<size_t>(i)] = i + 1;
             }
 
             atomic_pointer  a;
@@ -535,7 +535,7 @@ namespace misc {
             char   arr[8];
             const char aSize = sizeof(arr)/sizeof(arr[0]);
             for ( char i = 0; i < aSize; ++i ) {
-                arr[unsigned(i)] = i + 1;
+                arr[static_cast<size_t>(i)] = i + 1;
             }
 
             atomic_pointer  a;