Cpp Core Check

appveyor.yml

@@ -50,9 +50,10 @@ environment:
       OUTPUTXML_TYPE: xml
     # Prefast
     - job_group: VisualStudio
-      job_depends_on: VS2015
+      job_depends_on: VS2019
       BUILD_PREFAST: yes
-      PROJECT_DIR: vs2015
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      PROJECT_DIR: vs2019
     # Menu
     - job_group: VisualStudio
       BUILD_MENU: yes
@@ -280,9 +281,10 @@ for:
   environment:
     MSBUILD_LOGGER_OPTION: /verbosity:minimal /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
     MSBUILD_PREFAST_OPTION: /p:RunCodeAnalysis=true /p:EnablePREfast=true /p:CodeAnalysisTreatWarningsAsErrors=true
+    CPPCORE_CHECK_OPTION: /p:CodeAnalysisRuleSet=CppCoreCheckRules.ruleset
   before_build: *noop
   build_script:
-    cmd: msbuild "projects\%PROJECT_DIR%\iutest_sample.vcxproj" /m %MSBUILD_LOGGER_OPTION% %MSBUILD_PREFAST_OPTION%
+    cmd: msbuild "projects\%PROJECT_DIR%\iutest_sample.vcxproj" /m %MSBUILD_LOGGER_OPTION% %MSBUILD_PREFAST_OPTION% %CPPCORE_CHECK_OPTION% /p:ForceImportBeforeCppTargets=%APPVEYOR_BUILD_FOLDER%/utils/props/CppCoreCheckDisableSpecificWarnings.props
   test: off
   on_finish: *noop
 # Menu

include/impl/iutest_debug.ipp

@@ -2,11 +2,11 @@
 //-----------------------------------------------------------------------
 /**
  * @file        iutest_debug.ipp
- * @brief       iris unit test debug help ファイル
+ * @brief       iris unit test debug help implementation
  *
  * @author      t.shirayanagi
  * @par         copyright
- * Copyright (C) 2013-2016, Takazumi Shirayanagi\n
+ * Copyright (C) 2013-2021, Takazumi Shirayanagi\n
  * This software is released under the new BSD License,
  * see LICENSE
 */
@@ -40,10 +40,10 @@ namespace detail
 #if defined(_MSC_VER) && IUTEST_HAS_MINIDUMP
 
 IUTEST_IPP_INLINE MiniDump::MiniDump()
-    : m_hModule(NULL), m_pfnMiniDumpWriteDump(NULL)
+    : m_hModule(IUTEST_NULLPTR), m_pfnMiniDumpWriteDump(IUTEST_NULLPTR)
 {
     m_hModule = ::LoadLibraryA("dbghelp.dll");
-    if( m_hModule != NULL )
+    if( m_hModule != IUTEST_NULLPTR )
     {
         m_pfnMiniDumpWriteDump = ::GetProcAddress(m_hModule, "MiniDumpWriteDump");
     }
@@ -56,7 +56,7 @@ IUTEST_IPP_INLINE MiniDump::~MiniDump()
 
 IUTEST_IPP_INLINE bool MiniDump::Dump(HANDLE hFile, EXCEPTION_POINTERS* ep)
 {
-    if( m_pfnMiniDumpWriteDump == NULL )
+    if( m_pfnMiniDumpWriteDump == IUTEST_NULLPTR )
     {
         return false;
     }
@@ -73,13 +73,13 @@ IUTEST_IPP_INLINE bool MiniDump::Dump(HANDLE hFile, EXCEPTION_POINTERS* ep)
         );
     const pfnMiniDumpWriteDump proc = reinterpret_cast<const pfnMiniDumpWriteDump>(m_pfnMiniDumpWriteDump);
     return (*proc)( ::GetCurrentProcess(), ::GetCurrentProcessId(), hFile, MiniDumpNormal
-        , &mdei, NULL, NULL) ? true : false;
+        , &mdei, IUTEST_NULLPTR, IUTEST_NULLPTR) ? true : false;
 }
 IUTEST_IPP_INLINE bool MiniDump::Create(const char* filepath, EXCEPTION_POINTERS* ep)
 {
     HANDLE hFile = CreateFileA( filepath, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_WRITE|FILE_SHARE_READ
-        , NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-    if( hFile == NULL || hFile == INVALID_HANDLE_VALUE )
+        , IUTEST_NULLPTR, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, IUTEST_NULLPTR);
+    if( hFile == IUTEST_NULLPTR || hFile == INVALID_HANDLE_VALUE )
     {
         return false;
     }

include/internal/iutest_debug.hpp

@@ -6,7 +6,7 @@
  *
  * @author      t.shirayanagi
  * @par         copyright
- * Copyright (C) 2011-2020, Takazumi Shirayanagi\n
+ * Copyright (C) 2011-2021, Takazumi Shirayanagi\n
  * This software is released under the new BSD License,
  * see LICENSE
 */
@@ -38,7 +38,7 @@ namespace detail
 
 //======================================================================
 // function
-static void IUTEST_ATTRIBUTE_UNUSED_ iuDebugInitialize()
+static void IUTEST_ATTRIBUTE_UNUSED_ iuDebugInitialize() IUTEST_CXX_NOEXCEPT_SPEC
 {
 #ifdef _IUTEST_DEBUG
 #  if defined(_MSC_VER) && !defined(IUTEST_OS_WINDOWS_MOBILE)
@@ -54,7 +54,7 @@ static void IUTEST_ATTRIBUTE_UNUSED_ iuDebugBreakAlloc(long n)
     _CrtSetBreakAlloc(n);
 #  endif
 #endif
-    (void)n;
+    IUTEST_UNUSED_VAR(n);
 }
 
 #if defined(_MSC_VER) && IUTEST_HAS_MINIDUMP

include/internal/iutest_internal_defs.hpp

@@ -6,7 +6,7 @@
  *
  * @author      t.shirayanagi
  * @par         copyright
- * Copyright (C) 2011-2020, Takazumi Shirayanagi\n
+ * Copyright (C) 2011-2021, Takazumi Shirayanagi\n
  * This software is released under the new BSD License,
  * see LICENSE
 */
@@ -136,22 +136,22 @@ typedef ::iutest_compatible::IsNullLiteralHelper::Object* iu_nullptr_convertible
 /**
  * @brief   true を返す(警告対策用)
 */
-inline bool AlwaysTrue() { return true; }
+inline bool AlwaysTrue() IUTEST_CXX_NOEXCEPT_SPEC { return true; }
 
 /**
  * @brief   false を返す(警告対策用)
 */
-inline bool AlwaysFalse() { return !AlwaysTrue(); }
+inline bool AlwaysFalse() IUTEST_CXX_NOEXCEPT_SPEC { return !AlwaysTrue(); }
 
 /**
  * @brief   0 を返す(警告対策用)
 */
-inline int  AlwaysZero() { return 0; }
+inline int  AlwaysZero() IUTEST_CXX_NOEXCEPT_SPEC { return 0; }
 
 /**
  * @brief   真偽値を返す(警告対策用)
 */
-inline bool IsTrue(bool b) { return b; }
+inline bool IsTrue(bool b) IUTEST_CXX_NOEXCEPT_SPEC { return b; }
 
 //======================================================================
 // class

include/internal/iutest_stdlib.hpp

@@ -6,7 +6,7 @@
  *
  * @author      t.shirayanagi
  * @par         copyright
- * Copyright (C) 2012-2020, Takazumi Shirayanagi\n
+ * Copyright (C) 2012-2021, Takazumi Shirayanagi\n
  * This software is released under the new BSD License,
  * see LICENSE
 */
@@ -268,7 +268,7 @@ class optional
     T m_value;
 };
 
-inline bool uncaught_exception()
+inline bool uncaught_exception() IUTEST_CXX_NOEXCEPT_SPEC
 {
 #if IUTEST_HAS_CXX1Z && (!defined(IUTEST_LIBSTDCXX_VERSION) || (IUTEST_LIBSTDCXX_VERSION >= 60000))
     return ::std::uncaught_exceptions() > 0;
@@ -508,23 +508,6 @@ struct type_least_t : public type_t_helper::type_least_t_select<SIZE>::type {};
 
 //======================================================================
 // function
-/**
- * @internal
- * @brief   mbtowc
-*/
-inline int iu_mbtowc(wchar_t* dst, const char* src, size_t size)
-{
-#if defined(IUTEST_OS_LINUX_ANDROID) || defined(IUTEST_OS_WINDOWS_MOBILE)
-    // unimplimented
-    IUTEST_UNUSED_VAR(dst);
-    IUTEST_UNUSED_VAR(src);
-    IUTEST_UNUSED_VAR(size);
-    return 0;
-#else
-    return mbtowc(dst, src, size);
-#endif
-}
-
 template<typename T>
 T numeric_min()
 {

include/internal/iutest_string.hpp

@@ -44,14 +44,14 @@ ::std::string StringFormat(const char* format, va_list va) IUTEST_ATTRIBUTE_FORM
 namespace wrapper
 {
 
-inline int iu_mbicmp(char l, char r)
+inline int iu_mbicmp(char l, char r) IUTEST_CXX_NOEXCEPT_SPEC
 {
     const int ul = static_cast<int>(static_cast<unsigned char>(toupper(l)));
     const int ur = static_cast<int>(static_cast<unsigned char>(toupper(r)));
     return ul - ur;
 }
 
-inline int iu_stricmp(const char* str1, const char* str2)
+inline int iu_stricmp(const char* str1, const char* str2) IUTEST_CXX_NOEXCEPT_SPEC
 {
     const char* l = str1;
     const char* r = str2;
@@ -68,14 +68,14 @@ inline int iu_stricmp(const char* str1, const char* str2)
     return iu_mbicmp(*l, *r);
 }
 
-inline int iu_wcicmp(wchar_t l, wchar_t r)
+inline int iu_wcicmp(wchar_t l, wchar_t r) IUTEST_CXX_NOEXCEPT_SPEC
 {
     const ::std::wint_t ul = towupper(l);
     const ::std::wint_t ur = towupper(r);
     return ul - ur;
 }
 
-inline int iu_wcsicmp(const wchar_t * str1, const wchar_t * str2)
+inline int iu_wcsicmp(const wchar_t * str1, const wchar_t * str2) IUTEST_CXX_NOEXCEPT_SPEC
 {
     const wchar_t* l = str1;
     const wchar_t* r = str2;
@@ -94,11 +94,28 @@ inline int iu_wcsicmp(const wchar_t * str1, const wchar_t * str2)
 
 }   // end of namespace wrapper
 
+/**
+ * @internal
+ * @brief   mbtowc
+*/
+inline int iu_mbtowc(wchar_t* dst, const char* src, size_t size) IUTEST_CXX_NOEXCEPT_SPEC
+{
+#if defined(IUTEST_OS_LINUX_ANDROID) || defined(IUTEST_OS_WINDOWS_MOBILE)
+    // unimplimented
+    IUTEST_UNUSED_VAR(dst);
+    IUTEST_UNUSED_VAR(src);
+    IUTEST_UNUSED_VAR(size);
+    return 0;
+#else
+    return mbtowc(dst, src, size);
+#endif
+}
+
 /**
  * @internal
  * @brief   stricmp (unsigned char compare)
 */
-inline int iu_stricmp(const char* str1, const char* str2)
+inline int iu_stricmp(const char* str1, const char* str2) IUTEST_CXX_NOEXCEPT_SPEC
 {
 #if   defined(__BORLANDC__)
     return stricmp(str1, str2);
@@ -118,7 +135,7 @@ inline int iu_stricmp(const char* str1, const char* str2)
  * @internal
  * @brief   wcsicmp
 */
-inline int iu_wcsicmp(const wchar_t * str1, const wchar_t * str2)
+inline int iu_wcsicmp(const wchar_t * str1, const wchar_t * str2) IUTEST_CXX_NOEXCEPT_SPEC
 {
 #if   defined(_MSC_VER)
     return _wcsicmp(str1, str2);
@@ -137,9 +154,9 @@ int iu_vsnprintf(char* dst, size_t size, const char* format, va_list va) IUTEST_
 inline int iu_vsnprintf(char* dst, size_t size, const char* format, va_list va)
 {
     char buffer[4096] = {0};
-    char* write_buffer = dst != NULL && size >= 4096 ? dst : buffer;
+    char* write_buffer = dst != IUTEST_NULLPTR && size >= 4096 ? dst : buffer;
     const int ret = vsprintf(write_buffer, format, va);
-    if( dst != NULL )
+    if( dst != IUTEST_NULLPTR )
     {
         const size_t length = static_cast<size_t>(ret);
         const size_t write = (size <= length) ? size - 1 : length;
@@ -162,12 +179,12 @@ int iu_snprintf(char* dst, size_t size, const char* format, ...) IUTEST_ATTRIBUT
 */
 inline int iu_vsnprintf(char* dst, size_t size, const char* format, va_list va)
 {
-    if( dst == NULL && size > 0 )
+    if( dst == IUTEST_NULLPTR && size > 0 )
     {
         return -1;
     }
 #if   defined(_MSC_VER)
-    if( dst == NULL || size <= 0 )
+    if( dst == IUTEST_NULLPTR || size <= 0 )
     {
         return _vscprintf(format, va);
     }
@@ -201,29 +218,29 @@ inline int iu_snprintf(char* dst, size_t size, const char* format, ...)
 
 IUTEST_PRAGMA_CONSTEXPR_CALLED_AT_RUNTIME_WARN_DISABLE_BEGIN()
 
-inline bool IsEmpty(const char* p) { return p == NULL || *p == '\0'; }
-inline IUTEST_CXX_CONSTEXPR bool IsSpace(char ch) { return ch == ' ' || ch =='\t'; }
-inline const char* NullableString(const char* str) { return str == NULL ? "" : str; }
-inline IUTEST_CXX_CONSTEXPR const char* SkipSpace(const char* p)
+inline bool IsEmpty(const char* p) IUTEST_CXX_NOEXCEPT_SPEC { return p == IUTEST_NULLPTR || *p == '\0'; }
+inline IUTEST_CXX_CONSTEXPR bool IsSpace(char ch) IUTEST_CXX_NOEXCEPT_SPEC { return ch == ' ' || ch =='\t'; }
+inline const char* NullableString(const char* str) IUTEST_CXX_NOEXCEPT_SPEC { return str == IUTEST_NULLPTR ? "" : str; }
+inline IUTEST_CXX_CONSTEXPR const char* SkipSpace(const char* p) IUTEST_CXX_NOEXCEPT_SPEC
 {
-    return p == NULL ? NULL : (IsSpace(*p) ? SkipSpace(++p) : p);
+    return p == IUTEST_NULLPTR ? IUTEST_NULLPTR : (IsSpace(*p) ? SkipSpace(++p) : p);
 }
-inline IUTEST_CXX_CONSTEXPR const char* FindComma(const char* p)
+inline IUTEST_CXX_CONSTEXPR const char* FindComma(const char* p) IUTEST_CXX_NOEXCEPT_SPEC
 {
-    return (p == NULL || *p == '\0') ? NULL : ((*p == ',') ? p : FindComma(++p));
+    return (p == IUTEST_NULLPTR || *p == '\0') ? IUTEST_NULLPTR : ((*p == ',') ? p : FindComma(++p));
 }
-inline bool IsStringEqual(const char* str1, const char* str2) { return strcmp(str1, str2) == 0; }
-inline bool IsStringEqual(const ::std::string& str1, const char* str2) { return str1.compare(str2) == 0; }
-inline bool IsStringEqual(const ::std::string& str1, const ::std::string& str2) { return str1.compare(str2) == 0; }
-inline bool IsStringCaseEqual(const char* str1, const char* str2) { return iu_stricmp(str1, str2) == 0; }
-inline bool IsStringCaseEqual(const ::std::string& str1, const char* str2) { return iu_stricmp(str1.c_str(), str2) == 0; }
-inline bool IsStringCaseEqual(const ::std::string& str1, const ::std::string& str2) { return iu_stricmp(str1.c_str(), str2.c_str()) == 0; }
-inline bool IsStringForwardMatching(const char* str1, const char* str2) { return strstr(str1, str2) == str1; }
-inline bool IsStringForwardMatching(const ::std::string& str1, const char* str2) { return str1.find(str2) == 0; }
-inline bool IsStringForwardMatching(const ::std::string& str1, const std::string& str2) { return str1.find(str2) == 0; }
-inline bool IsStringContains(const char* str1, const char* str2) { return strstr(str1, str2) != NULL; }
-inline bool IsStringContains(const ::std::string& str1, const char* str2) { return str1.find(str2) != ::std::string::npos; }
-inline bool IsStringContains(const ::std::string& str1, const ::std::string& str2) { return str1.find(str2) != ::std::string::npos; }
+inline bool IsStringEqual(const char* str1, const char* str2) IUTEST_CXX_NOEXCEPT_SPEC { return strcmp(str1, str2) == 0; }
+inline bool IsStringEqual(const ::std::string& str1, const char* str2) IUTEST_CXX_NOEXCEPT_SPEC { return str1.compare(str2) == 0; }
+inline bool IsStringEqual(const ::std::string& str1, const ::std::string& str2) IUTEST_CXX_NOEXCEPT_SPEC { return str1.compare(str2) == 0; }
+inline bool IsStringCaseEqual(const char* str1, const char* str2) IUTEST_CXX_NOEXCEPT_SPEC { return iu_stricmp(str1, str2) == 0; }
+inline bool IsStringCaseEqual(const ::std::string& str1, const char* str2) IUTEST_CXX_NOEXCEPT_SPEC { return iu_stricmp(str1.c_str(), str2) == 0; }
+inline bool IsStringCaseEqual(const ::std::string& str1, const ::std::string& str2) IUTEST_CXX_NOEXCEPT_SPEC { return iu_stricmp(str1.c_str(), str2.c_str()) == 0; }
+inline bool IsStringForwardMatching(const char* str1, const char* str2) IUTEST_CXX_NOEXCEPT_SPEC { return strstr(str1, str2) == str1; }
+inline bool IsStringForwardMatching(const ::std::string& str1, const char* str2) IUTEST_CXX_NOEXCEPT_SPEC { return str1.find(str2) == 0; }
+inline bool IsStringForwardMatching(const ::std::string& str1, const std::string& str2) IUTEST_CXX_NOEXCEPT_SPEC { return str1.find(str2) == 0; }
+inline bool IsStringContains(const char* str1, const char* str2) IUTEST_CXX_NOEXCEPT_SPEC { return strstr(str1, str2) != IUTEST_NULLPTR; }
+inline bool IsStringContains(const ::std::string& str1, const char* str2) IUTEST_CXX_NOEXCEPT_SPEC { return str1.find(str2) != ::std::string::npos; }
+inline bool IsStringContains(const ::std::string& str1, const ::std::string& str2) IUTEST_CXX_NOEXCEPT_SPEC { return str1.find(str2) != ::std::string::npos; }
 
 inline void StringReplace(::std::string& str, const char* from, size_t n, const char* to)
 {
@@ -236,7 +253,7 @@ inline void StringReplace(::std::string& str, const char* from, size_t n, const
 }
 inline void StringReplace(::std::string& str, char a, const char* to)
 {
-    char s[] = { a, 0 };
+    const char s[] = { a, 0 };
     return StringReplace(str, s, 1, to);
 }
 inline ::std::string StripLeadingSpace(const ::std::string& str)
@@ -442,7 +459,7 @@ inline ::std::string FormatSizeByte(UInt64 value)
         "GB",
         "TB",
     };
-    const size_t suffixes_length = IUTEST_PP_COUNTOF(suffixes);
+    IUTEST_CXX_CONSTEXPR_OR_CONST size_t suffixes_length = IUTEST_PP_COUNTOF(suffixes);
     size_t index = 0;
     double view_value = static_cast<double>(value);
     while(view_value >= 1024 && index + 1 < suffixes_length)
@@ -489,7 +506,7 @@ inline ::std::string StringFormat(const char* format, va_list va)
     {
         va_list va2;
         iu_va_copy(va2, va);    // cppcheck-suppress va_list_usedBeforeStarted
-        const int ret = iu_vsnprintf(NULL, 0u, format, va2);
+        const int ret = iu_vsnprintf(IUTEST_NULLPTR, 0u, format, va2);
         va_end(va2);
         if( ret > 0 )
         {