Fix compiler warnings for issue #23.

Author: colinrg

test/TestClass.hpp

@@ -828,7 +828,7 @@ class TestClass
         msg.Append("time ");
         if (m_timed_function_calls > 0)
         {
-            diff_time /= m_timed_function_calls;
+            diff_time /= static_cast<size_t>(m_timed_function_calls);
             privateAppendTime(msg, diff_time, false);
         }
         else

test/TestMemoryUtility.hpp

@@ -44,7 +44,7 @@ struct TestMemoryUtility
     {
         GetCounter().Inc();
         SizeType const alloc_size_in_bytes = elements * sizeof(Type);
-        Type* ptr = static_cast<Type*>(::malloc(alloc_size_in_bytes));
+        Type* ptr = static_cast<Type*>(::malloc(static_cast<size_t>(alloc_size_in_bytes)));
         return ptr;
     }
 

test/TestNumericUtility.hpp

@@ -74,7 +74,7 @@ struct TestNumericUtility
         char* str = NULL;
         if (max_chars > 0)
         {
-            TestMemoryUtility<char>::Allocate(str, max_chars + 1);
+            TestMemoryUtility<char, SizeType>::Allocate(str, max_chars + 1);
             if (str != NULL)
             {
                 sprintf(str, fmt, value);

test/TestString.hpp

@@ -221,7 +221,7 @@ class TestString
         if ((count > 0) && remove)
         {
             size_type chars_remaining = m_length - sub_str.m_length - start;
-            ::memmove(m_string + start, m_string + start + count, chars_remaining);
+            ::memmove(m_string + start, m_string + start + count, static_cast<size_t>(chars_remaining));
             *(m_string + start + chars_remaining) = '\0';
             m_length -= count;
             if (m_length == 0)
@@ -389,7 +389,7 @@ class TestString
                     char* start = str;
                     for (char* str_end = str + count; str < str_end; ++str)
                         *str = ch;
-                    ::memcpy(str, value, value_len);
+                    ::memcpy(str, value, static_cast<size_t>(value_len));
                     *(str + value_len) = '\0';
                     Append(start, count + value_len);
                     TestStringUtility::FastFree(start);

test/TestStringUtility.hpp

@@ -202,8 +202,8 @@ struct TestStringUtility
 #pragma warning(push)
 #pragma warning(disable : 4996)
 #endif
-        return static_cast<CharType*>(::memcpy(dest, src,
-                                      (UnsafeLength(src) + 1) * sizeof(CharType)));
+        size_t copy_size = static_cast<size_t>((UnsafeLength(src) + 1) * sizeof(CharType));
+        return static_cast<CharType*>(::memcpy(dest, src, copy_size));
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
@@ -252,7 +252,7 @@ struct TestStringUtility
     template<typename CharType>
     static void Allocate(CharType*& dest, size_type dest_len)
     {
-        dest = TestMemoryUtility<CharType>::Allocate(dest_len + 1);
+        dest = TestMemoryUtility<CharType, size_type>::Allocate(dest_len + 1);
     }
 
     template<typename CharType>
@@ -275,7 +275,7 @@ struct TestStringUtility
     {
         if ((src != NULL) && (src_len > 0))
         {
-            dest = TestMemoryUtility<CharType>::UnsafeAllocateCopy(src, src_len + 1);
+            dest = TestMemoryUtility<CharType, size_type>::UnsafeAllocateCopy(src, src_len + 1);
             if (dest != NULL)
             {
                 dest_len = src_len;
@@ -314,7 +314,7 @@ struct TestStringUtility
                                    CharType const* src,
                                    size_type src_len)
     {
-        dest = TestMemoryUtility<CharType>::UnsafeAllocateCopy(src, src_len + 1);
+        dest = TestMemoryUtility<CharType, size_type>::UnsafeAllocateCopy(src, src_len + 1);
         dest_len = (dest != NULL) ? src_len : static_cast<size_type>(0);
     }
 
@@ -351,7 +351,7 @@ struct TestStringUtility
                 }
                 else
                 {
-                    ::memcpy(dest, src, dest_len + 1);
+                    ::memcpy(dest, src, static_cast<size_t>(dest_len + 1));
                     dest_len = len;
                 }
             }
@@ -387,14 +387,14 @@ struct TestStringUtility
             if (new_dest != NULL)
             {
                 if ((str1 != NULL) && (str1_len > static_cast<size_type>(0)))
-                    ::memcpy(new_dest, str1, str1_len);
+                    ::memcpy(new_dest, str1, static_cast<size_t>(str1_len));
                 else
                 {
                     new_len -= str1_len;
                     str1_len = static_cast<size_type>(0);
                 }
                 if ((str2 != NULL) && (str2_len > static_cast<size_type>(0)))
-                    ::memcpy(new_dest + str1_len, str2, str2_len);
+                    ::memcpy(new_dest + str1_len, str2, static_cast<size_t>(str2_len));
                 else
                     new_len -= str2_len;
                 SetNullChar(*(new_dest + new_len));

test/TestTime.hpp

@@ -109,7 +109,7 @@ class TestTime
 
     TestTime& operator /=(size_t div_by) throw()
     {
-        m_nanoseconds /= div_by;
+        m_nanoseconds /= static_cast<ocl_uint64>(div_by);
         return *this;
     }