diff options
Diffstat (limited to 'libs/ode-0.16.1/ou/test/outest.cpp')
| -rw-r--r-- | libs/ode-0.16.1/ou/test/outest.cpp | 9027 |
1 files changed, 9027 insertions, 0 deletions
diff --git a/libs/ode-0.16.1/ou/test/outest.cpp b/libs/ode-0.16.1/ou/test/outest.cpp new file mode 100644 index 0000000..2ddfdef --- /dev/null +++ b/libs/ode-0.16.1/ou/test/outest.cpp @@ -0,0 +1,9027 @@ +/************************************************************************* + * * + * ODER's Utilities Library. Copyright (C) 2008 Oleh Derevenko. * + * All rights reserved. e-mail: odar@eleks.com (change all "a" to "e") * + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of EITHER: * + * (1) The GNU Lesser General Public License as published by the Free * + * Software Foundation; either version 3 of the License, or (at * + * your option) any later version. The text of the GNU Lesser * + * General Public License is included with this library in the * + * file LICENSE-LESSER.TXT. Since LGPL is the extension of GPL * + * the text of GNU General Public License is also provided for * + * your information in file LICENSE.TXT. * + * (2) The BSD-style license that is included with this library in * + * the file LICENSE-BSD.TXT. * + * (3) The zlib/libpng license that is included with this library in * + * the file LICENSE-ZLIB.TXT * + * * + * This library is distributed WITHOUT ANY WARRANTY, including implied * + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * + * See the files LICENSE.TXT and LICENSE-LESSER.TXT or LICENSE-BSD.TXT * + * or LICENSE-ZLIB.TXT for more details. * + * * + *************************************************************************/ + +#include <ou/features.h> +#include <ou/platform.h> + +#if _OU_COMPILER == _OU_COMPILER_MSVC + +#pragma warning(disable:4786) + + +#endif + +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS +#include <ou/threadlocalstorage.h> +#endif +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS +#include <ou/atomic.h> +#endif +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS +#include <ou/atomicflags.h> +#endif +#include <ou/simpleflags.h> +#include <ou/flagsdefines.h> +#include <ou/enumarrays.h> +#include <ou/templates.h> +#include <ou/typewrapper.h> +#include <ou/customization.h> +#include <ou/inttypes.h> +#include <ou/macros.h> +#include <ou/malloc.h> + +#include <ou/namespace.h> +using namespace _OU_NAMESPACE; + +#include <stdio.h> +#include <string.h> + + +////////////////////////////////////////////////////////////////////////// + +typedef bool (*CFeatureTestProcedure)(); + + +bool TestSubsystem(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount, + const unsigned int uiFeatureMax, const char *const *aszFeatureNames, CFeatureTestProcedure const *afnFeatureTests) +{ + unsigned int nSuccessCount = 0; + + for (unsigned int uiSubsystemFeature = 0; uiSubsystemFeature != uiFeatureMax; ++uiSubsystemFeature) + { + const char *szFeatureName = aszFeatureNames[uiSubsystemFeature]; + printf("Testing %34s: ", szFeatureName); + + CFeatureTestProcedure fnTestProcedure = afnFeatureTests[uiSubsystemFeature]; + bool bTestResult = fnTestProcedure(); + printf("%s\n", bTestResult ? "success" : "*** failure ***"); + + if (bTestResult) + { + nSuccessCount += 1; + } + } + + nOutSuccessCount = nSuccessCount; + nOutTestCount = uiFeatureMax; + return nSuccessCount == uiFeatureMax; +} + + + +////////////////////////////////////////////////////////////////////////// + +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS + +bool g_bTestTLSAPIInitialized = false; +HTLSKEY g_htkTestTLSKey; + +enum ETESTTLSVALUES +{ + TTV_FIRSTVALUE, + TTV_SECONDVALUE, + + TTV__MAX, +}; + +unsigned int g_uiTestTLSDestructorCallCount = 0; +unsigned int g_uiTestTLSDestructorSuccessCount = 0; + +void _OU_CONVENTION_CALLBACK TestTlsSecondValueDestructor(void *pv_Value) +{ + g_uiTestTLSDestructorCallCount += 1; + + if (pv_Value == (void *)(&TestTlsSecondValueDestructor)) + { + g_uiTestTLSDestructorSuccessCount += 1; + } +} + + +bool TestTls_Initialization() +{ + bool bResult = false; + + do + { + if (!CTLSInitialization::InitializeTLSAPI(g_htkTestTLSKey, 1, 0)) + { + break; + } + + CTLSInitialization::FinalizeTLSAPI(); + + if (!CTLSInitialization::InitializeTLSAPI(g_htkTestTLSKey, TTV__MAX, CTLSInitialization::SIF_MANUAL_CLEANUP_ON_THREAD_EXIT)) + { + break; + } + + g_bTestTLSAPIInitialized = true; + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTls_GetSetValue() +{ + bool bResult = false; + + do + { + tlsvaluetype vtFirstValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE); + + if (vtFirstValue != 0) + { + break; + } + + tlsvaluetype vtSecondValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE); + + if (vtSecondValue != 0) + { + break; + } + + if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE, (tlsvaluetype)&TestTls_GetSetValue)) + { + break; + } + + if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, (tlsvaluetype)&TestTlsSecondValueDestructor, &TestTlsSecondValueDestructor)) + { + break; + } + + vtFirstValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE); + + if ((void *)vtFirstValue != &TestTls_GetSetValue) + { + break; + } + + vtSecondValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE); + + if ((void *)vtSecondValue != &TestTlsSecondValueDestructor) + { + break; + } + + if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, 0, &TestTlsSecondValueDestructor)) + { + break; + } + + vtSecondValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE); + + if (vtSecondValue != 0) + { + break; + } + + if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, (tlsvaluetype)&TestTlsSecondValueDestructor, &TestTlsSecondValueDestructor)) + { + break; + } + + if (g_uiTestTLSDestructorCallCount != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTls_UnsafeGetSetValue() +{ + bool bResult = false; + + do + { + tlsvaluetype vtFirstValue = CThreadLocalStorage::UnsafeGetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE); + + if ((void *)vtFirstValue != &TestTls_GetSetValue) + { + break; + } + + tlsvaluetype vtSecondValue = CThreadLocalStorage::UnsafeGetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE); + + if ((void *)vtSecondValue != &TestTlsSecondValueDestructor) + { + break; + } + + CThreadLocalStorage::UnsafeSetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE, (tlsvaluetype)(size_t)(-1)); + CThreadLocalStorage::UnsafeSetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, (tlsvaluetype)(size_t)(-1)); + + vtFirstValue = CThreadLocalStorage::UnsafeGetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE); + + if ((size_t)vtFirstValue != (size_t)(-1)) + { + break; + } + + vtSecondValue = CThreadLocalStorage::UnsafeGetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE); + + if ((size_t)vtSecondValue != (size_t)(-1)) + { + break; + } + + // Safe function used by intent !!! + vtFirstValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE); + + if ((size_t)vtFirstValue != (size_t)(-1)) + { + break; + } + + // Safe function used by intent !!! + vtSecondValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE); + + if ((size_t)vtSecondValue != (size_t)(-1)) + { + break; + } + + CThreadLocalStorage::UnsafeSetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, (tlsvaluetype)(&TestTlsSecondValueDestructor)); + + if (g_uiTestTLSDestructorCallCount != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTls_CleanupDestructor() +{ + bool bResult = false; + + do + { + CTLSInitialization::CleanupOnThreadExit(); + + if (g_uiTestTLSDestructorCallCount != 1 || g_uiTestTLSDestructorSuccessCount != 1) + { + break; + } + + tlsvaluetype vtFirstValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_FIRSTVALUE); + + if (vtFirstValue != 0) + { + break; + } + + // Safe function used by intent !!! + tlsvaluetype vtSecondValue = CThreadLocalStorage::GetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE); + + if (vtSecondValue != 0) + { + break; + } + + g_uiTestTLSDestructorCallCount = 0; + g_uiTestTLSDestructorSuccessCount = 0; + + CTLSInitialization::CleanupOnThreadExit(); + + if (g_uiTestTLSDestructorCallCount != 0) + { + break; + } + + if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, 0, &TestTlsSecondValueDestructor)) + { + break; + } + + CTLSInitialization::CleanupOnThreadExit(); + + if (g_uiTestTLSDestructorCallCount != 0) + { + break; + } + + if (!CThreadLocalStorage::SetStorageValue(g_htkTestTLSKey, TTV_SECONDVALUE, (tlsvaluetype)(size_t)(-1), &TestTlsSecondValueDestructor)) + { + break; + } + + if (g_uiTestTLSDestructorCallCount != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTls_Finalization() +{ + OU_ASSERT(g_bTestTLSAPIInitialized); + + bool bResult = false; + + do + { + CTLSInitialization::FinalizeTLSAPI(); + + g_bTestTLSAPIInitialized = false; + + if (g_uiTestTLSDestructorCallCount != 1 || g_uiTestTLSDestructorSuccessCount != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUTLSFEATURE +{ + OHF__MIN, + + OHF_INITIALIZATION = OHF__MIN, + OHF_GETSETVALUE, + OHF_UNSAFEGETSETVALUE, + OHF_CLEANUPDESTRUCTOR, + OHF_FINALIZATION, + + OHF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUTLSFEATURE, OHF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestTls_Initialization, // OHF_INITIALIZATION + &TestTls_GetSetValue, // OHF_GETSETVALUE, + &TestTls_UnsafeGetSetValue, // OHF_UNSAFEGETSETVALUE, + &TestTls_CleanupDestructor, // OHF_CLEANUPDESTRUCTOR, + &TestTls_Finalization, // OHF_FINALIZATION, +}; +static const CEnumUnsortedElementArray<EOUTLSFEATURE, OHF__MAX, CFeatureTestProcedure> g_afnTlsFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUTLSFEATURE, OHF__MAX, const char *>::m_aetElementArray[] = +{ + "API Initialization", // OHF_INITIALIZATION + "Get.../SetStorageValue", // OHF_GETSETVALUE, + "UnsafeGet.../UnsafeSetStorageValue", // OHF_UNSAFEGETSETVALUE, + "Storage Cleanup/Value Destructors", // OHF_CLEANUPDESTRUCTOR, + "API Finalization", // OHF_FINALIZATION, +}; +static const CEnumUnsortedElementArray<EOUTLSFEATURE, OHF__MAX, const char *> g_aszTlsFeatureTestNames; + + +bool TestTLS(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + bool bResult = TestSubsystem(nOutSuccessCount, nOutTestCount, OHF__MAX, g_aszTlsFeatureTestNames.GetStoragePointer(), g_afnTlsFeatureTestProcedures.GetStoragePointer()); + + if (g_bTestTLSAPIInitialized) + { + CTLSInitialization::FinalizeTLSAPI(); + } + + return bResult; +} + + +#endif // #if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS + + +////////////////////////////////////////////////////////////////////////// + +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS + +bool TestAtomic_Increment() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = (atomicord32)(-1); + + // Putting function inside of conditional operator causes + // incorrect code generation by GCC 4.0.1 on MacOS X Leopard 64 bit. + atomicord32 aoIncrementFirstResult = AtomicIncrement(&aoStorage); + if (aoIncrementFirstResult != 0 || aoStorage != (atomicord32)0) + { + break; + } + + if (AtomicIncrement(&aoStorage) != (atomicord32)1 || aoStorage != (atomicord32)1) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_Decrement() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = (atomicord32)1; + + // Putting function inside of conditional operator causes + // incorrect code generation by GCC 4.0.1 on MacOS X Leopard 64 bit. + atomicord32 aoDecrementFirstResult = AtomicDecrement(&aoStorage); + if (aoDecrementFirstResult != (atomicord32)0 || aoStorage != (atomicord32)0) + { + break; + } + + if (AtomicDecrement(&aoStorage) != (atomicord32)(-1) || aoStorage != (atomicord32)(-1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_IncrementNoResult() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = (atomicord32)(-1); + + AtomicIncrementNoResult(&aoStorage); + + if (aoStorage != (atomicord32)0) + { + break; + } + + AtomicIncrementNoResult(&aoStorage); + + if (aoStorage != (atomicord32)1) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_DecrementNoResult() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = (atomicord32)1; + + AtomicDecrementNoResult(&aoStorage); + + if (aoStorage != (atomicord32)0) + { + break; + } + + AtomicDecrementNoResult(&aoStorage); + + if (aoStorage != (atomicord32)(-1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_Exchange() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = 0; + + if (AtomicExchange(&aoStorage, (atomicord32)1) != 0 || aoStorage != (atomicord32)1) + { + break; + } + + if (AtomicExchange(&aoStorage, (atomicord32)(-1)) != (atomicord32)1 || aoStorage != (atomicord32)(-1)) + { + break; + } + + if (AtomicExchange(&aoStorage, 0) != (atomicord32)(-1) || aoStorage != 0) + { + break; + } + + if (AtomicExchange(&aoStorage, 0) != 0 || aoStorage != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; + +} + +bool TestAtomic_ExchangeAdd() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = 0; + + if (AtomicExchangeAdd(&aoStorage, (atomicord32)1) != 0 || aoStorage != (atomicord32)1) + { + break; + } + + if (AtomicExchangeAdd(&aoStorage, (atomicord32)(-2)) != 1 || aoStorage != (atomicord32)(-1)) + { + break; + } + + if (AtomicExchangeAdd(&aoStorage, (atomicord32)1) != (atomicord32)(-1) || aoStorage != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_ExchangeAddNoResult() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = 0; + + AtomicExchangeAddNoResult(&aoStorage, (atomicord32)1); + + if (aoStorage != (atomicord32)1) + { + break; + } + + AtomicExchangeAddNoResult(&aoStorage, (atomicord32)(-2)); + + if (aoStorage != (atomicord32)(-1)) + { + break; + } + + AtomicExchangeAddNoResult(&aoStorage, (atomicord32)1); + + if (aoStorage != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_CompareExchange() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = 0; + + if (AtomicCompareExchange(&aoStorage, 1, 1) || aoStorage != 0) + { + break; + } + + if (!AtomicCompareExchange(&aoStorage, 0, 1) || aoStorage != 1) + { + break; + } + + if (!AtomicCompareExchange(&aoStorage, 1, 1) || aoStorage != 1) + { + break; + } + + if (!AtomicCompareExchange(&aoStorage, 1, (atomicord32)(-1)) || aoStorage != (atomicord32)(-1)) + { + break; + } + + if (AtomicCompareExchange(&aoStorage, 1, (atomicord32)(-1)) || aoStorage != (atomicord32)(-1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +const atomicord32 g_aoBitmask = (atomicord32)(OU_INT32_MIN + 1); + +bool TestAtomic_And() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = (atomicord32)OU_UINT32_MAX; + + if (AtomicAnd(&aoStorage, g_aoBitmask) != (atomicord32)OU_UINT32_MAX || aoStorage != g_aoBitmask) + { + break; + } + + if (AtomicAnd(&aoStorage, 0) != g_aoBitmask || aoStorage != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_Or() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = 0; + + if (AtomicOr(&aoStorage, g_aoBitmask) != 0 || aoStorage != g_aoBitmask) + { + break; + } + + if (AtomicOr(&aoStorage, (atomicord32)OU_UINT32_MAX) != g_aoBitmask || aoStorage != (atomicord32)OU_UINT32_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_Xor() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = 0; + + if (AtomicXor(&aoStorage, g_aoBitmask) != 0 || aoStorage != g_aoBitmask) + { + break; + } + + if (AtomicXor(&aoStorage, (atomicord32)OU_UINT32_MAX) != g_aoBitmask || aoStorage != (atomicord32)(OU_UINT32_MAX ^ g_aoBitmask)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_AndNoResult() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = (atomicord32)OU_UINT32_MAX; + + AtomicAndNoResult(&aoStorage, g_aoBitmask); + + if (aoStorage != g_aoBitmask) + { + break; + } + + AtomicAndNoResult(&aoStorage, 0); + + if (aoStorage != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_OrNoResult() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = 0; + + AtomicOrNoResult(&aoStorage, g_aoBitmask); + + if (aoStorage != g_aoBitmask) + { + break; + } + + AtomicOrNoResult(&aoStorage, (atomicord32)OU_UINT32_MAX); + + if (aoStorage != (atomicord32)OU_UINT32_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_XorNoResult() +{ + bool bResult = false; + + do + { + volatile atomicord32 aoStorage = 0; + + AtomicXorNoResult(&aoStorage, g_aoBitmask); + + if (aoStorage != g_aoBitmask) + { + break; + } + + AtomicXorNoResult(&aoStorage, (atomicord32)OU_UINT32_MAX); + + if (aoStorage != (atomicord32)(OU_UINT32_MAX ^ g_aoBitmask)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_ExchangePointer() +{ + bool bResult = false; + + do + { + volatile atomicptr apStorage = NULL; + + if (AtomicExchangePointer(&apStorage, (atomicptr)(&TestAtomic_ExchangePointer)) != NULL || apStorage != (atomicptr)(&TestAtomic_ExchangePointer)) + { + break; + } + + if (AtomicExchangePointer(&apStorage, (atomicptr)(&apStorage)) != (atomicptr)(&TestAtomic_ExchangePointer) || apStorage != (atomicptr)(&apStorage)) + { + break; + } + + if (AtomicExchangePointer(&apStorage, NULL) != (atomicptr)(&apStorage) || apStorage != NULL) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomic_CompareExchangePointer() +{ + bool bResult = false; + + do + { + volatile atomicptr apStorage = NULL; + + if (AtomicCompareExchangePointer(&apStorage, (atomicptr)(&TestAtomic_CompareExchangePointer), (atomicptr)(&TestAtomic_CompareExchangePointer)) || apStorage != NULL) + { + break; + } + + if (!AtomicCompareExchangePointer(&apStorage, NULL, (atomicptr)(&TestAtomic_CompareExchangePointer)) || apStorage != (atomicptr)(&TestAtomic_CompareExchangePointer)) + { + break; + } + + if (!AtomicCompareExchangePointer(&apStorage, (atomicptr)(&TestAtomic_CompareExchangePointer), (atomicptr)(&apStorage)) || apStorage != (atomicptr)(&apStorage)) + { + break; + } + + if (!AtomicCompareExchangePointer(&apStorage, (atomicptr)(&apStorage), (atomicptr)(&apStorage)) || apStorage != (atomicptr)(&apStorage)) + { + break; + } + + if (AtomicCompareExchangePointer(&apStorage, NULL, NULL) || apStorage != (atomicptr)(&apStorage)) + { + break; + } + + if (!AtomicCompareExchangePointer(&apStorage, (atomicptr)(&apStorage), NULL) || apStorage != NULL) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUATOMICFEATURE +{ + OOF__MIN, + + OOF_INCREMENT = OOF__MIN, + OOF_DECREMENT, + OOF_INCREMENTNORESULT, + OOF_DECREMENTNORESULT, + OOF_EXCHANGE, + OOF_EXCHANGEADD, + OOF_EXCHANGEADDNORESULT, + OOF_COMPAREEXCHANGE, + OOF_AND, + OOF_OR, + OOF_XOR, + OOF_ANDNORESULT, + OOF_ORNORESULT, + OOF_XORNORESULT, + OOF_EXCHANGEPOINTER, + OOF_COMPAREEXCHANGEPOINTER, + + OOF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUATOMICFEATURE, OOF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestAtomic_Increment, // OOF_INCREMENT, + &TestAtomic_Decrement, // OOF_DECREMENT, + &TestAtomic_IncrementNoResult, // OOF_INCREMENTNORESULT, + &TestAtomic_DecrementNoResult, // OOF_DECREMENTNORESULT, + &TestAtomic_Exchange, // OOF_EXCHANGE, + &TestAtomic_ExchangeAdd, // OOF_EXCHANGEADD, + &TestAtomic_ExchangeAddNoResult, // OOF_EXCHANGEADDNORESULT, + &TestAtomic_CompareExchange, // OOF_COMPAREEXCHANGE, + &TestAtomic_And, // OOF_AND, + &TestAtomic_Or, // OOF_OR, + &TestAtomic_Xor, // OOF_XOR, + &TestAtomic_AndNoResult, // OOF_ANDNORESULT, + &TestAtomic_OrNoResult, // OOF_ORNORESULT, + &TestAtomic_XorNoResult, // OOF_XORNORESULT, + &TestAtomic_ExchangePointer, // OOF_EXCHANGEPOINTER, + &TestAtomic_CompareExchangePointer, // OOF_COMPAREEXCHANGEPOINTER, +}; +static const CEnumUnsortedElementArray<EOUATOMICFEATURE, OOF__MAX, CFeatureTestProcedure> g_afnAtomicFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUATOMICFEATURE, OOF__MAX, const char *>::m_aetElementArray[] = +{ + "AtomicIncrement", // OOF_INCREMENT, + "AtomicDecrement", // OOF_DECREMENT, + "AtomicIncrementNoResult", // OOF_INCREMENTNORESULT, + "AtomicDecrementNoResult", // OOF_DECREMENTNORESULT, + "AtomicExchange", // OOF_EXCHANGE, + "AtomicExchangeAdd", // OOF_EXCHANGEADD, + "AtomicExchangeAddNoResult", // OOF_EXCHANGEADDNORESULT, + "AtomicCompareExchange", // OOF_COMPAREEXCHANGE, + "AtomicAnd", // OOF_AND, + "AtomicOr", // OOF_OR, + "AtomicXor", // OOF_XOR, + "AtomicAndNoResult", // OOF_ANDNORESULT, + "AtomicOrNoResult", // OOF_ORNORESULT, + "AtomicXorNoResult", // OOF_XORNORESULT, + "AtomicExchangePointer", // OOF_EXCHANGEPOINTER, + "AtomicCompareExchangePointer", // OOF_COMPAREEXCHANGEPOINTER, +}; +static const CEnumUnsortedElementArray<EOUATOMICFEATURE, OOF__MAX, const char *> g_aszAtomicFeatureTestNames; + + +bool TestAtomic(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + bool bResult = false; + nOutSuccessCount = 0; + nOutTestCount = OOF__MAX; + + bool bAPIInitialized = false; + + do + { + if (!InitializeAtomicAPI()) + { + break; + } + + bAPIInitialized = true; + + if (!TestSubsystem(nOutSuccessCount, nOutTestCount, OOF__MAX, g_aszAtomicFeatureTestNames.GetStoragePointer(), g_afnAtomicFeatureTestProcedures.GetStoragePointer())) + { + break; + } + + bResult = true; + } + while (false); + + if (bAPIInitialized) + { + FinalizeAtomicAPI(); + } + + return bResult; +} + + +#endif // #if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS + + +////////////////////////////////////////////////////////////////////////// + +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS + +const atomicord32 g_aoTestValue32 = (atomicord32)0xA5A5A5A5; +const atomicord32 g_aoTestMask32 = (atomicord32)0xC6C6C6C6; +const atomicord32 g_aoTestBit32 = (atomicord32)OU_INT32_MIN; +const atomicord32 g_aoTestAnotherBit32 = (atomicord32)((uint32ou)OU_INT32_MIN >> 1); + + +bool TestAtomicFlags_Constructors() +{ + bool bResult = false; + + do + { + if (sizeof(CAtomicFlags::value_type) != sizeof(atomicord32)) + { + break; + } + + CAtomicFlags afEmptyFlags; + + if (afEmptyFlags.QueryFlagsAllValues()) + { + break; + } + + CAtomicFlags afFullFlags(OU_UINT32_MAX); + + if (afFullFlags.QueryFlagsAllValues() != (atomicord32)OU_UINT32_MAX) + { + break; + } + + CAtomicFlags afCopyOfFullFlags(afFullFlags); + + if (afCopyOfFullFlags.QueryFlagsAllValues() != (atomicord32)OU_UINT32_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_AssignFlagsAllValues() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags; + + afTestFlags.AssignFlagsAllValues(OU_UINT32_MAX); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)OU_UINT32_MAX) + { + break; + } + + afTestFlags.AssignFlagsAllValues(0); + + if (afTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_QueryFlagsAllValues() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + + if (afTestFlags.QueryFlagsAllValues() != g_aoTestValue32) + { + break; + } + + // Double check to be sure ;-) + if (afTestFlags.QueryFlagsAllValues() != g_aoTestValue32) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_SetFlagsMaskValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + + afTestFlags.SetFlagsMaskValue(g_aoTestMask32, true); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(g_aoTestValue32 | g_aoTestMask32)) + { + break; + } + + afTestFlags.SetFlagsMaskValue(g_aoTestValue32, false); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(~g_aoTestValue32 & g_aoTestMask32)) + { + break; + } + + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_SignalFlagsMaskValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + + afTestFlags.SignalFlagsMaskValue(g_aoTestMask32); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(g_aoTestValue32 | g_aoTestMask32)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_DropFlagsMaskValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + + afTestFlags.DropFlagsMaskValue(g_aoTestMask32); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(g_aoTestValue32 & ~g_aoTestMask32)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_ToggleSingleFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + + bool bPreviousValue = afTestFlags.ToggleSingleFlagValue(g_aoTestBit32); + + if (bPreviousValue != ((g_aoTestValue32 & g_aoTestBit32) != 0) || afTestFlags.QueryFlagsAllValues() != (atomicord32)(g_aoTestValue32 ^ g_aoTestBit32)) + { + break; + } + + bool bAnotherPreviousValue = afTestFlags.ToggleSingleFlagValue(g_aoTestBit32); + + if (bAnotherPreviousValue == bPreviousValue || afTestFlags.QueryFlagsAllValues() != g_aoTestValue32) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_ModifySingleFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + + bool bFirstModification = afTestFlags.ModifySingleFlagValue(g_aoTestBit32, true); + + if (bFirstModification != ((g_aoTestValue32 & g_aoTestBit32) != g_aoTestBit32) || afTestFlags.QueryFlagsAllValues() != (atomicord32)(g_aoTestValue32 | g_aoTestBit32)) + { + break; + } + + bool bAnotherModification = afTestFlags.ModifySingleFlagValue(g_aoTestBit32, bFirstModification); + + if (bAnotherModification == bFirstModification || afTestFlags.QueryFlagsAllValues() != (bFirstModification ? (atomicord32)(g_aoTestValue32 | g_aoTestBit32) : (atomicord32)(g_aoTestValue32 & ~g_aoTestBit32))) + { + break; + } + + bool bYetAnotherModification = afTestFlags.ModifySingleFlagValue(g_aoTestBit32, bAnotherModification); + + if (bYetAnotherModification != bAnotherModification || afTestFlags.QueryFlagsAllValues() != (bAnotherModification ? (atomicord32)(g_aoTestValue32 | g_aoTestBit32) : (atomicord32)(g_aoTestValue32 & ~g_aoTestBit32))) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_AssignFlagsByMask() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + + atomicord32 aoPreviousFlags = afTestFlags.AssignFlagsByMask(g_aoTestMask32, g_aoTestMask32); + + const atomicord32 aoNewFlags = (g_aoTestValue32 & ~g_aoTestMask32) | g_aoTestMask32; + + if (aoPreviousFlags != g_aoTestValue32 || afTestFlags.QueryFlagsAllValues() != aoNewFlags) + { + break; + } + + atomicord32 aoAnotherPreviousFlags = afTestFlags.AssignFlagsByMask(g_aoTestValue32, 0); + + const atomicord32 aoAnotherNewFlags = aoNewFlags & ~g_aoTestValue32; + + if (aoAnotherPreviousFlags != aoNewFlags || afTestFlags.QueryFlagsAllValues() != aoAnotherNewFlags) + { + break; + } + + atomicord32 aoYetAnotherPreviousFlags = afTestFlags.AssignFlagsByMask(g_aoTestMask32, g_aoTestMask32 & g_aoTestValue32); + OU_ASSERT((g_aoTestMask32 & g_aoTestValue32) != 0); // Test degeneration + + const atomicord32 aoYetAnotherNewFlags = (aoAnotherNewFlags & ~g_aoTestMask32) | (g_aoTestMask32 & g_aoTestValue32); + OU_ASSERT(aoYetAnotherNewFlags != (atomicord32)OU_UINT32_MAX); // Test degeneration + + if (aoYetAnotherPreviousFlags != aoAnotherNewFlags || afTestFlags.QueryFlagsAllValues() != aoYetAnotherNewFlags) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_AlterFlagsByMask() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + + bool bWasModification = afTestFlags.AlterFlagsByMask(g_aoTestMask32, g_aoTestMask32); + + const atomicord32 aoNewFlags = (g_aoTestValue32 & ~g_aoTestMask32) | g_aoTestMask32; + + if (bWasModification != ((g_aoTestValue32 & g_aoTestMask32) != g_aoTestMask32) || afTestFlags.QueryFlagsAllValues() != aoNewFlags) + { + break; + } + + bool bWasAnotherModification = afTestFlags.AlterFlagsByMask(g_aoTestValue32, 0); + + const atomicord32 aoAnotherNewFlags = aoNewFlags & ~g_aoTestValue32; + + if (bWasAnotherModification != ((aoNewFlags & g_aoTestValue32) != 0) || afTestFlags.QueryFlagsAllValues() != aoAnotherNewFlags) + { + break; + } + + bool bWasAnotherModificationRepeated = afTestFlags.AlterFlagsByMask(g_aoTestValue32, 0); + + if (bWasAnotherModificationRepeated || afTestFlags.QueryFlagsAllValues() != aoAnotherNewFlags) + { + break; + } + + bool bWasYetAnotherModification = afTestFlags.AlterFlagsByMask(g_aoTestMask32, g_aoTestMask32 & g_aoTestValue32); + OU_ASSERT((g_aoTestMask32 & g_aoTestValue32) != 0); // Test degeneration + + const atomicord32 aoYetAnotherNewFlags = (aoAnotherNewFlags & ~g_aoTestMask32) | (g_aoTestMask32 & g_aoTestValue32); + OU_ASSERT(aoYetAnotherNewFlags != (atomicord32)OU_UINT32_MAX); // Test degeneration + + if (bWasYetAnotherModification != ((aoAnotherNewFlags & g_aoTestMask32) != (g_aoTestMask32 & g_aoTestValue32)) || afTestFlags.QueryFlagsAllValues() != aoYetAnotherNewFlags) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_GetFlagsMaskValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + + if (afTestFlags.GetFlagsMaskValue(g_aoTestMask32) != ((g_aoTestValue32 & g_aoTestMask32) != 0)) + { + break; + } + + if (afTestFlags.GetFlagsMaskValue(~g_aoTestValue32)) + { + break; + } + + if (!afTestFlags.GetFlagsMaskValue(OU_UINT32_MAX)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_QueryFlagsByMask() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + + if (afTestFlags.QueryFlagsByMask(g_aoTestMask32) != (atomicord32)(g_aoTestValue32 & g_aoTestMask32)) + { + break; + } + + if (afTestFlags.QueryFlagsByMask(0)) + { + break; + } + + if (afTestFlags.QueryFlagsByMask(OU_UINT32_MAX) != g_aoTestValue32) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_OnlySignalSingleFlagOutOfMask() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(g_aoTestValue32); + OU_ASSERT(g_aoTestValue32 != 0); // Test degeneration + + if (afTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT32_MAX, g_aoTestBit32)) + { + break; + } + + if (afTestFlags.QueryFlagsAllValues() != g_aoTestValue32) + { + break; + } + + afTestFlags.AssignFlagsAllValues(0); + + if (!afTestFlags.OnlySignalSingleFlagOutOfMask(g_aoTestBit32, g_aoTestBit32)) + { + break; + } + + if (afTestFlags.QueryFlagsAllValues() != g_aoTestBit32) + { + break; + } + + if (afTestFlags.OnlySignalSingleFlagOutOfMask(g_aoTestBit32, g_aoTestBit32)) + { + break; + } + + if (afTestFlags.QueryFlagsAllValues() != g_aoTestBit32) + { + break; + } + + if (afTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT32_MAX, g_aoTestAnotherBit32)) + { + break; + } + + if (afTestFlags.QueryFlagsAllValues() != g_aoTestBit32) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumSetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags; + + afTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true); + + if (afTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + afTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1)) + { + break; + } + + afTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT32_BITS, false); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)OU_INT32_MIN) + { + break; + } + + afTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, false); + + if (afTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumSignalEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags; + + afTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (afTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + afTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1)) + { + break; + } + + afTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1)) + { + break; + } + + afTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumDropEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(OU_UINT32_MAX); + + afTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_UINT32_MAX ^ 1)) + { + break; + } + + afTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)~(OU_INT32_MIN + 1)) + { + break; + } + + afTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)~(OU_INT32_MIN + 1)) + { + break; + } + + afTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)~(OU_INT32_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumToggleEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags; + + bool bToggleFirstResult = afTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (bToggleFirstResult || afTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bToggleSecondResult = afTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (bToggleSecondResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1)) + { + break; + } + + bool bToggleThirdResult = afTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (!bToggleThirdResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)OU_INT32_MIN) + { + break; + } + + bool bToggleFourthResult = afTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (!bToggleFourthResult || afTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumModifyEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags; + + bool bModifyFirstResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true); + + if (!bModifyFirstResult || afTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bModifySecondResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true); + + if (!bModifySecondResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1)) + { + break; + } + + bool bModifyThirdResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true); + + if (bModifyThirdResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1)) + { + break; + } + + bool bModifyFourthResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true); + + if (bModifyFourthResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 1)) + { + break; + } + + bool bModifyFifthResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, false); + + if (!bModifyFifthResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)OU_INT32_MIN) + { + break; + } + + bool bModifySixthResult = afTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, false); + + if (!bModifySixthResult || afTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumSignalFirstEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags; + + bool bFirstResult = afTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (!bFirstResult || afTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bSecondResult = afTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (bSecondResult || afTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bThirdResult = afTestFlags.EnumSignalFirstEnumeratedFlagValue(2, 0, OU_UINT32_BITS - 1); + + if (!bThirdResult || afTestFlags.QueryFlagsAllValues() != 3) + { + break; + } + + bool bFourthResult = afTestFlags.EnumSignalFirstEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (bFourthResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 3)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumSignalLastEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags; + + bool bFirstResult = afTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1); + + if (!bFirstResult || afTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bSecondResult = afTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1); + + if (bSecondResult || afTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bThirdResult = afTestFlags.EnumSignalLastEnumeratedFlagValue(1, 1, 2); + + if (!bThirdResult || afTestFlags.QueryFlagsAllValues() != 3) + { + break; + } + + bool bFourthResult = afTestFlags.EnumSignalLastEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (bFourthResult || afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_INT32_MIN + 3)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumGetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags((atomicord32)(OU_INT32_MIN + 1)); + + if (!afTestFlags.EnumGetEnumeratedFlagValue(1, 0, OU_UINT32_BITS)) + { + break; + } + + if (afTestFlags.EnumGetEnumeratedFlagValue(2, 0, OU_UINT32_BITS - 1)) + { + break; + } + + if (afTestFlags.EnumGetEnumeratedFlagValue(1, 1, OU_UINT32_BITS - 1)) + { + break; + } + + if (!afTestFlags.EnumGetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumFindFirstEnumeratedFlag() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags((atomicord32)(OU_INT32_MIN + 1)); + + unsigned int uiFirstResult = afTestFlags.EnumFindFirstEnumeratedFlag(1, OU_UINT32_BITS); + if (uiFirstResult != 0) + { + break; + } + + unsigned int uiSecondResult = afTestFlags.EnumFindFirstEnumeratedFlag(2, OU_UINT32_BITS - 1); + if (uiSecondResult != OU_UINT32_BITS - 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumAllSignalEnumeratedFlags() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags; + + afTestFlags.EnumAllSignalEnumeratedFlags(1, 1); + + if (afTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + afTestFlags.EnumAllSignalEnumeratedFlags(4, OU_UINT32_BITS - 2); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_UINT32_MAX ^ 2)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumAllDropEnumeratedFlags() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags(OU_UINT32_MAX); + + afTestFlags.EnumAllDropEnumeratedFlags(1, 1); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(OU_UINT32_MAX ^ 1)) + { + break; + } + + afTestFlags.EnumAllDropEnumeratedFlags(4, OU_UINT32_BITS - 2); + + if (afTestFlags.QueryFlagsAllValues() != 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumAllQueryEnumeratedFlags() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags((atomicord32)(OU_INT32_MIN + 1)); + + atomicord32 aoFirstResult = afTestFlags.EnumAllQueryEnumeratedFlags(1, OU_UINT32_BITS); + if (aoFirstResult != (atomicord32)(OU_INT32_MIN + 1)) + { + break; + } + + atomicord32 aoSecondResult = afTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT32_BITS - 1); + if (aoSecondResult != (atomicord32)(OU_INT32_MIN)) + { + break; + } + + atomicord32 aoThirdResult = afTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT32_BITS - 2); + if (aoThirdResult != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_EnumAnyGetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags((atomicord32)(OU_INT32_MIN + 1)); + + bool bFirstResult = afTestFlags.EnumAnyGetEnumeratedFlagValue(1, OU_UINT32_BITS); + if (!bFirstResult) + { + break; + } + + bool bSecondResult = afTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT32_BITS - 1); + if (!bSecondResult) + { + break; + } + + bool bThirdResult = afTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT32_BITS - 2); + if (bThirdResult) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_StoreFlagsEnumeratedValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags; + + afTestFlags.StoreFlagsEnumeratedValue(0x03, 1, 2); + + if (afTestFlags.QueryFlagsAllValues() != (atomicord32)(2 << 1)) + { + break; + } + + afTestFlags.StoreFlagsEnumeratedValue(0x03, OU_UINT32_BITS - 2, 3); + + if (afTestFlags.QueryFlagsAllValues() != ((atomicord32)(2 << 1) | (atomicord32)(OU_INT32_MIN | (OU_INT32_MIN >> 1)))) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestAtomicFlags_RetrieveFlagsEnumeratedValue() +{ + bool bResult = false; + + do + { + CAtomicFlags afTestFlags((atomicord32)(OU_INT32_MIN + 1)); + + unsigned int aoFirstResult = afTestFlags.RetrieveFlagsEnumeratedValue(0x3, 1); + if (aoFirstResult != 0) + { + break; + } + + unsigned int aoSecondResult = afTestFlags.RetrieveFlagsEnumeratedValue(0x3, OU_UINT32_BITS - 2); + if (aoSecondResult != 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUATOMICFLAGSFEATURE +{ + OAF__MIN, + + OAF_CONSTRUCTORS = OAF__MIN, + OAF_ASSIGNFLAGSALLVALUES, + OAF_QUERYFLAGSALLVALUES, + OAF_SETFLAGSMASKVALUE, + OAF_SIGNALFLAGSMASKVALUE, + OAF_DROPFLAGSMASKVALUE, + OAF_TOGGLESINGLEFLAGVALUE, + OAF_MODIFYSINGLEFLAGVALUE, + OAF_ASSIGNFLAGSBYMASK, + OAF_ALTERFLAGSBYMASK, + OAF_GETFLAGSMASKVALUE, + OAF_QUERYFLAGSBYMASK, + OAF_ONLYSIGNALSINGLEFLAGOUTOFMASK, + OAF_ENUMSETENUMERATEDFLAGVALUE, + OAF_ENUMSIGNALENUMERATEDFLAGVALUE, + OAF_ENUMDROPENUMERATEDFLAGVALUE, + OAF_ENUMTOGGLEENUMERATEDFLAGVALUE, + OAF_ENUMMODIFYENUMERATEDFLAGVALUE, + OAF_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + OAF_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + OAF_ENUMGETENUMERATEDFLAGVALUE, + OAF_ENUMFINDFIRSTENUMERATEDFLAG, + OAF_ENUMALLSIGNALENUMERATEDFLAGS, + OAF_ENUMALLDROPENUMERATEDFLAGS, + OAF_ENUMALLQUERYENUMERATEDFLAGS, + OAF_ENUMANYGETENUMERATEDFLAGVALUE, + OAF_STOREFLAGSENUMERATEDVALUE, + OAF_RETRIEVEFLAGSENUMERATEDVALUE, + + OAF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUATOMICFLAGSFEATURE, OAF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestAtomicFlags_Constructors, // OAF_CONSTRUCTORS + &TestAtomicFlags_AssignFlagsAllValues, // OAF_ASSIGNFLAGSALLVALUES, + &TestAtomicFlags_QueryFlagsAllValues, // OAF_QUERYFLAGSALLVALUES, + &TestAtomicFlags_SetFlagsMaskValue, // OAF_SETFLAGSMASKVALUE, + &TestAtomicFlags_SignalFlagsMaskValue, // OAF_SIGNALFLAGSMASKVALUE, + &TestAtomicFlags_DropFlagsMaskValue, // OAF_DROPFLAGSMASKVALUE, + &TestAtomicFlags_ToggleSingleFlagValue, // OAF_TOGGLESINGLEFLAGVALUE, + &TestAtomicFlags_ModifySingleFlagValue, // OAF_MODIFYSINGLEFLAGVALUE, + &TestAtomicFlags_AssignFlagsByMask, // OAF_ASSIGNFLAGSBYMASK, + &TestAtomicFlags_AlterFlagsByMask, // OAF_ALTERFLAGSBYMASK, + &TestAtomicFlags_GetFlagsMaskValue, // OAF_GETFLAGSMASKVALUE, + &TestAtomicFlags_QueryFlagsByMask, // OAF_QUERYFLAGSBYMASK, + &TestAtomicFlags_OnlySignalSingleFlagOutOfMask, // OAF_ONLYSIGNALSINGLEFLAGOUTOFMASK, + &TestAtomicFlags_EnumSetEnumeratedFlagValue, // OAF_ENUMSETENUMERATEDFLAGVALUE, + &TestAtomicFlags_EnumSignalEnumeratedFlagValue, // OAF_ENUMSIGNALENUMERATEDFLAGVALUE, + &TestAtomicFlags_EnumDropEnumeratedFlagValue, // OAF_ENUMDROPENUMERATEDFLAGVALUE, + &TestAtomicFlags_EnumToggleEnumeratedFlagValue, // OAF_ENUMTOGGLEENUMERATEDFLAGVALUE, + &TestAtomicFlags_EnumModifyEnumeratedFlagValue, // OAF_ENUMMODIFYENUMERATEDFLAGVALUE, + &TestAtomicFlags_EnumSignalFirstEnumeratedFlagValue, // OAF_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + &TestAtomicFlags_EnumSignalLastEnumeratedFlagValue, // OAF_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + &TestAtomicFlags_EnumGetEnumeratedFlagValue, // OAF_ENUMGETENUMERATEDFLAGVALUE, + &TestAtomicFlags_EnumFindFirstEnumeratedFlag, // OAF_ENUMFINDFIRSTENUMERATEDFLAG, + &TestAtomicFlags_EnumAllSignalEnumeratedFlags, // OAF_ENUMALLSIGNALENUMERATEDFLAGS, + &TestAtomicFlags_EnumAllDropEnumeratedFlags, // OAF_ENUMALLDROPENUMERATEDFLAGS, + &TestAtomicFlags_EnumAllQueryEnumeratedFlags, // OAF_ENUMALLQUERYENUMERATEDFLAGS, + &TestAtomicFlags_EnumAnyGetEnumeratedFlagValue, // OAF_ENUMANYGETENUMERATEDFLAGVALUE, + &TestAtomicFlags_StoreFlagsEnumeratedValue, // OAF_STOREFLAGSENUMERATEDVALUE, + &TestAtomicFlags_RetrieveFlagsEnumeratedValue, // OAF_RETRIEVEFLAGSENUMERATEDVALUE, +}; +static const CEnumUnsortedElementArray<EOUATOMICFLAGSFEATURE, OAF__MAX, CFeatureTestProcedure> g_afnAtomicFlagsFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUATOMICFLAGSFEATURE, OAF__MAX, const char *>::m_aetElementArray[] = +{ + "Constructors", // OAF_CONSTRUCTORS + "AssignFlagsAllValues", // OAF_ASSIGNFLAGSALLVALUES, + "QueryFlagsAllValues", // OAF_QUERYFLAGSALLVALUES, + "SetFlagsMaskValue", // OAF_SETFLAGSMASKVALUE, + "SignalFlagsMaskValue", // OAF_SIGNALFLAGSMASKVALUE, + "DropFlagsMaskValue", // OAF_DROPFLAGSMASKVALUE, + "ToggleSingleFlagValue", // OAF_TOGGLESINGLEFLAGVALUE, + "ModifySingleFlagValue", // OAF_MODIFYSINGLEFLAGVALUE, + "AssignFlagsByMask", // OAF_ASSIGNFLAGSBYMASK, + "AlterFlagsByMask", // OAF_ALTERFLAGSBYMASK, + "GetFlagsMaskValue", // OAF_GETFLAGSMASKVALUE, + "QueryFlagsByMask", // OAF_QUERYFLAGSBYMASK, + "OnlySignalSingleFlagOutOfMask", // OAF_ONLYSIGNALSINGLEFLAGOUTOFMASK, + "EnumSetEnumeratedFlagValue", // OAF_ENUMSETENUMERATEDFLAGVALUE, + "EnumSignalEnumeratedFlagValue", // OAF_ENUMSIGNALENUMERATEDFLAGVALUE, + "EnumDropEnumeratedFlagValue", // OAF_ENUMDROPENUMERATEDFLAGVALUE, + "EnumToggleEnumeratedFlagValue", // OAF_ENUMTOGGLEENUMERATEDFLAGVALUE, + "EnumModifyEnumeratedFlagValue", // OAF_ENUMMODIFYENUMERATEDFLAGVALUE, + "EnumSignalFirstEnumeratedFlagValue", // OAF_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + "EnumSignalLastEnumeratedFlagValue", // OAF_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + "EnumGetEnumeratedFlagValue", // OAF_ENUMGETENUMERATEDFLAGVALUE, + "EnumFindFirstEnumeratedFlag", // OAF_ENUMFINDFIRSTENUMERATEDFLAG, + "EnumAllSignalEnumeratedFlags", // OAF_ENUMALLSIGNALENUMERATEDFLAGS, + "EnumAllDropEnumeratedFlags", // OAF_ENUMALLDROPENUMERATEDFLAGS, + "EnumAllQueryEnumeratedFlags", // OAF_ENUMALLQUERYENUMERATEDFLAGS, + "EnumAnyGetEnumeratedFlagValue", // OAF_ENUMANYGETENUMERATEDFLAGVALUE, + "StoreFlagsEnumeratedValue", // OAF_STOREFLAGSENUMERATEDVALUE, + "RetrieveFlagsEnumeratedValue", // OAF_RETRIEVEFLAGSENUMERATEDVALUE, +}; +static const CEnumUnsortedElementArray<EOUATOMICFLAGSFEATURE, OAF__MAX, const char *> g_aszAtomicFlagsFeatureTestNames; + + +bool TestAtomicFlags(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + bool bResult = false; + nOutSuccessCount = 0; + nOutTestCount = OAF__MAX; + + bool bAPIInitialized = false; + + do + { + if (!InitializeAtomicAPI()) + { + break; + } + + bAPIInitialized = true; + + if (!TestSubsystem(nOutSuccessCount, nOutTestCount, OAF__MAX, g_aszAtomicFlagsFeatureTestNames.GetStoragePointer(), g_afnAtomicFlagsFeatureTestProcedures.GetStoragePointer())) + { + break; + } + + bResult = true; + } + while (false); + + if (bAPIInitialized) + { + FinalizeAtomicAPI(); + } + + return bResult; +} + + +#endif // #if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS + + +////////////////////////////////////////////////////////////////////////// + +typedef CSimpleFlagsTemplate<uint64ou> CSimpleFlags64; + +const uint64ou g_uiTestValue64 = ((uint64ou)0xA5A5A5A5 << 32) | 0xA5A5A5A5; +const uint64ou g_uiTestMask64 = ((uint64ou)0xC6C6C6C6 << 32) | 0xC6C6C6C6; +const uint64ou g_uiTestBit64 = (uint64ou)OU_INT64_MIN; +const uint64ou g_uiTestAnotherBit64 = (uint64ou)((uint64ou)OU_INT64_MIN >> 1); + + +bool TestSimpleFlags64_Constructors() +{ + bool bResult = false; + + do + { + if (sizeof(CSimpleFlags64::value_type) != sizeof(uint64ou) || sizeof(CSimpleFlags64) != sizeof(uint64ou)) + { + break; + } + + CSimpleFlags64 sfEmptyFlags; + + if (sfEmptyFlags.QueryFlagsAllValues()) + { + break; + } + + CSimpleFlags64 sfFullFlags(OU_UINT64_MAX); + + if (sfFullFlags.QueryFlagsAllValues() != OU_UINT64_MAX) + { + break; + } + + CSimpleFlags64 sfCopyOfFullFlags(sfFullFlags); + + if (sfCopyOfFullFlags.QueryFlagsAllValues() != OU_UINT64_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_AssignFlagsAllValues() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags; + + sfTestFlags.AssignFlagsAllValues(OU_UINT64_MAX); + + if (sfTestFlags.QueryFlagsAllValues() != OU_UINT64_MAX) + { + break; + } + + sfTestFlags.AssignFlagsAllValues(0); + + if (sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_QueryFlagsAllValues() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue64) + { + break; + } + + // Double check to be sure ;-) + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue64) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_SetFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + + sfTestFlags.SetFlagsMaskValue(g_uiTestMask64, true); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(g_uiTestValue64 | g_uiTestMask64)) + { + break; + } + + sfTestFlags.SetFlagsMaskValue(g_uiTestValue64, false); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(~g_uiTestValue64 & g_uiTestMask64)) + { + break; + } + + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_SignalFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + + sfTestFlags.SignalFlagsMaskValue(g_uiTestMask64); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(g_uiTestValue64 | g_uiTestMask64)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_DropFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + + sfTestFlags.DropFlagsMaskValue(g_uiTestMask64); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(g_uiTestValue64 & ~g_uiTestMask64)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_ToggleSingleFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + + bool bPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit64); + + if (bPreviousValue != ((g_uiTestValue64 & g_uiTestBit64) != 0) || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(g_uiTestValue64 ^ g_uiTestBit64)) + { + break; + } + + bool bAnotherPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit64); + + if (bAnotherPreviousValue == bPreviousValue || sfTestFlags.QueryFlagsAllValues() != g_uiTestValue64) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_ModifySingleFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + + bool bFirstModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit64, true); + + if (bFirstModification != ((g_uiTestValue64 & g_uiTestBit64) != g_uiTestBit64) || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(g_uiTestValue64 | g_uiTestBit64)) + { + break; + } + + bool bAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit64, bFirstModification); + + if (bAnotherModification == bFirstModification || sfTestFlags.QueryFlagsAllValues() != (bFirstModification ? (uint64ou)(g_uiTestValue64 | g_uiTestBit64) : (uint64ou)(g_uiTestValue64 & ~g_uiTestBit64))) + { + break; + } + + bool bYetAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit64, bAnotherModification); + + if (bYetAnotherModification != bAnotherModification || sfTestFlags.QueryFlagsAllValues() != (bAnotherModification ? (uint64ou)(g_uiTestValue64 | g_uiTestBit64) : (uint64ou)(g_uiTestValue64 & ~g_uiTestBit64))) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_AssignFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + + uint64ou uiPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask64, g_uiTestMask64); + + const uint64ou uiNewFlags = (g_uiTestValue64 & ~g_uiTestMask64) | g_uiTestMask64; + + if (uiPreviousFlags != g_uiTestValue64 || sfTestFlags.QueryFlagsAllValues() != uiNewFlags) + { + break; + } + + uint64ou uiAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestValue64, 0); + + const uint64ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue64; + + if (uiAnotherPreviousFlags != uiNewFlags || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + uint64ou uiYetAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask64, g_uiTestMask64 & g_uiTestValue64); + OU_ASSERT((g_uiTestMask64 & g_uiTestValue64) != 0); // Test degeneration + + const uint64ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask64) | (g_uiTestMask64 & g_uiTestValue64); + OU_ASSERT(uiYetAnotherNewFlags != OU_UINT64_MAX); // Test degeneration + + if (uiYetAnotherPreviousFlags != uiAnotherNewFlags || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_AlterFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + + bool bWasModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask64, g_uiTestMask64); + + const uint64ou uiNewFlags = (g_uiTestValue64 & ~g_uiTestMask64) | g_uiTestMask64; + + if (bWasModification != ((g_uiTestValue64 & g_uiTestMask64) != g_uiTestMask64) || sfTestFlags.QueryFlagsAllValues() != uiNewFlags) + { + break; + } + + bool bWasAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestValue64, 0); + + const uint64ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue64; + + if (bWasAnotherModification != ((uiNewFlags & g_uiTestValue64) != 0) || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + bool bWasAnotherModificationRepeated = sfTestFlags.AlterFlagsByMask(g_uiTestValue64, 0); + + if (bWasAnotherModificationRepeated || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + bool bWasYetAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask64, g_uiTestMask64 & g_uiTestValue64); + OU_ASSERT((g_uiTestMask64 & g_uiTestValue64) != 0); // Test degeneration + + const uint64ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask64) | (g_uiTestMask64 & g_uiTestValue64); + OU_ASSERT(uiYetAnotherNewFlags != OU_UINT64_MAX); // Test degeneration + + if (bWasYetAnotherModification != ((uiAnotherNewFlags & g_uiTestMask64) != (g_uiTestMask64 & g_uiTestValue64)) || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_GetFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + + if (sfTestFlags.GetFlagsMaskValue(g_uiTestMask64) != ((g_uiTestValue64 & g_uiTestMask64) != 0)) + { + break; + } + + if (sfTestFlags.GetFlagsMaskValue(~g_uiTestValue64)) + { + break; + } + + if (!sfTestFlags.GetFlagsMaskValue(OU_UINT64_MAX)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_QueryFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + + if (sfTestFlags.QueryFlagsByMask(g_uiTestMask64) != (uint64ou)(g_uiTestValue64 & g_uiTestMask64)) + { + break; + } + + if (sfTestFlags.QueryFlagsByMask(0)) + { + break; + } + + if (sfTestFlags.QueryFlagsByMask(OU_UINT64_MAX) != g_uiTestValue64) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_OnlySignalSingleFlagOutOfMask() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(g_uiTestValue64); + OU_ASSERT(g_uiTestValue64 != 0); // Test degeneration + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT64_MAX, g_uiTestBit64)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue64) + { + break; + } + + sfTestFlags.AssignFlagsAllValues(0); + + if (!sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit64, g_uiTestBit64)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit64) + { + break; + } + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit64, g_uiTestBit64)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit64) + { + break; + } + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT64_MAX, g_uiTestAnotherBit64)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit64) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumSetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags; + + sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT64_BITS, true); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS, true); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT64_BITS, false); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)OU_INT64_MIN) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS, false); + + if (sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumSignalEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags; + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT64_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT64_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumDropEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(OU_UINT64_MAX); + + sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT64_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (OU_UINT64_MAX ^ 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)~(OU_INT64_MIN + 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT64_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)~(OU_INT64_MIN + 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)~(OU_INT64_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumToggleEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags; + + bool bToggleFirstResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT64_BITS); + + if (bToggleFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bToggleSecondResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS); + + if (bToggleSecondResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1)) + { + break; + } + + bool bToggleThirdResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT64_BITS); + + if (!bToggleThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)OU_INT64_MIN) + { + break; + } + + bool bToggleFourthResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS); + + if (!bToggleFourthResult || sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumModifyEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags; + + bool bModifyFirstResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT64_BITS, true); + + if (!bModifyFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bModifySecondResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS, true); + + if (!bModifySecondResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1)) + { + break; + } + + bool bModifyThirdResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT64_BITS, true); + + if (bModifyThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1)) + { + break; + } + + bool bModifyFourthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS, true); + + if (bModifyFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 1)) + { + break; + } + + bool bModifyFifthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT64_BITS, false); + + if (!bModifyFifthResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)OU_INT64_MIN) + { + break; + } + + bool bModifySixthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS, false); + + if (!bModifySixthResult || sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumSignalFirstEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags; + + bool bFirstResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT64_BITS); + + if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT64_BITS); + + if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(2, 0, OU_UINT64_BITS - 1); + + if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3) + { + break; + } + + bool bFourthResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS); + + if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 3)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumSignalLastEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags; + + bool bFirstResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1); + + if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1); + + if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 1, 2); + + if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3) + { + break; + } + + bool bFourthResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS); + + if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_INT64_MIN + 3)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumGetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags((uint64ou)(OU_INT64_MIN + 1)); + + if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, 0, OU_UINT64_BITS)) + { + break; + } + + if (sfTestFlags.EnumGetEnumeratedFlagValue(2, 0, OU_UINT64_BITS - 1)) + { + break; + } + + if (sfTestFlags.EnumGetEnumeratedFlagValue(1, 1, OU_UINT64_BITS - 1)) + { + break; + } + + if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, OU_UINT64_BITS - 1, OU_UINT64_BITS)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumFindFirstEnumeratedFlag() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags((uint64ou)(OU_INT64_MIN + 1)); + + unsigned int uiFirstResult = sfTestFlags.EnumFindFirstEnumeratedFlag(1, OU_UINT64_BITS); + if (uiFirstResult != 0) + { + break; + } + + unsigned int uiSecondResult = sfTestFlags.EnumFindFirstEnumeratedFlag(2, OU_UINT64_BITS - 1); + if (uiSecondResult != OU_UINT64_BITS - 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumAllSignalEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags; + + sfTestFlags.EnumAllSignalEnumeratedFlags(1, 1); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumAllSignalEnumeratedFlags(4, OU_UINT64_BITS - 2); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_UINT64_MAX ^ 2)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumAllDropEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags(OU_UINT64_MAX); + + sfTestFlags.EnumAllDropEnumeratedFlags(1, 1); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(OU_UINT64_MAX ^ 1)) + { + break; + } + + sfTestFlags.EnumAllDropEnumeratedFlags(4, OU_UINT64_BITS - 2); + + if (sfTestFlags.QueryFlagsAllValues() != 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumAllQueryEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags((uint64ou)(OU_INT64_MIN + 1)); + + uint64ou uiFirstResult = sfTestFlags.EnumAllQueryEnumeratedFlags(1, OU_UINT64_BITS); + if (uiFirstResult != (uint64ou)(OU_INT64_MIN + 1)) + { + break; + } + + uint64ou uiSecondResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT64_BITS - 1); + if (uiSecondResult != (uint64ou)(OU_INT64_MIN)) + { + break; + } + + uint64ou uiThirdResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT64_BITS - 2); + if (uiThirdResult != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_EnumAnyGetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags((uint64ou)(OU_INT64_MIN + 1)); + + bool bFirstResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(1, OU_UINT64_BITS); + if (!bFirstResult) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT64_BITS - 1); + if (!bSecondResult) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT64_BITS - 2); + if (bThirdResult) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_StoreFlagsEnumeratedValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags; + + sfTestFlags.StoreFlagsEnumeratedValue(0x03, 1, 2); + + if (sfTestFlags.QueryFlagsAllValues() != (uint64ou)(2 << 1)) + { + break; + } + + sfTestFlags.StoreFlagsEnumeratedValue(0x03, OU_UINT64_BITS - 2, 3); + + if (sfTestFlags.QueryFlagsAllValues() != ((uint64ou)(2 << 1) | (uint64ou)(OU_INT64_MIN | (OU_INT64_MIN >> 1)))) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags64_RetrieveFlagsEnumeratedValue() +{ + bool bResult = false; + + do + { + CSimpleFlags64 sfTestFlags((uint64ou)(OU_INT64_MIN + 1)); + + unsigned int uiFirstResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, 1); + if (uiFirstResult != 0) + { + break; + } + + unsigned int uiSecondResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, OU_UINT64_BITS - 2); + if (uiSecondResult != 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUSIMPLEFLAGSFEATURE64 +{ + OSF64__MIN, + + OSF64_CONSTRUCTORS = OSF64__MIN, + OSF64_ASSIGNFLAGSALLVALUES, + OSF64_QUERYFLAGSALLVALUES, + OSF64_SETFLAGSMASKVALUE, + OSF64_SIGNALFLAGSMASKVALUE, + OSF64_DROPFLAGSMASKVALUE, + OSF64_TOGGLESINGLEFLAGVALUE, + OSF64_MODIFYSINGLEFLAGVALUE, + OSF64_ASSIGNFLAGSBYMASK, + OSF64_ALTERFLAGSBYMASK, + OSF64_GETFLAGSMASKVALUE, + OSF64_QUERYFLAGSBYMASK, + OSF64_ONLYSIGNALSINGLEFLAGOUTOFMASK, + OSF64_ENUMSETENUMERATEDFLAGVALUE, + OSF64_ENUMSIGNALENUMERATEDFLAGVALUE, + OSF64_ENUMDROPENUMERATEDFLAGVALUE, + OSF64_ENUMTOGGLEENUMERATEDFLAGVALUE, + OSF64_ENUMMODIFYENUMERATEDFLAGVALUE, + OSF64_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + OSF64_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + OSF64_ENUMGETENUMERATEDFLAGVALUE, + OSF64_ENUMFINDFIRSTENUMERATEDFLAG, + OSF64_ENUMALLSIGNALENUMERATEDFLAGS, + OSF64_ENUMALLDROPENUMERATEDFLAGS, + OSF64_ENUMALLQUERYENUMERATEDFLAGS, + OSF64_ENUMANYGETENUMERATEDFLAGVALUE, + OSF64_STOREFLAGSENUMERATEDVALUE, + OSF64_RETRIEVEFLAGSENUMERATEDVALUE, + + OSF64__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE64, OSF64__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestSimpleFlags64_Constructors, // OSF64_CONSTRUCTORS + &TestSimpleFlags64_AssignFlagsAllValues, // OSF64_ASSIGNFLAGSALLVALUES, + &TestSimpleFlags64_QueryFlagsAllValues, // OSF64_QUERYFLAGSALLVALUES, + &TestSimpleFlags64_SetFlagsMaskValue, // OSF64_SETFLAGSMASKVALUE, + &TestSimpleFlags64_SignalFlagsMaskValue, // OSF64_SIGNALFLAGSMASKVALUE, + &TestSimpleFlags64_DropFlagsMaskValue, // OSF64_DROPFLAGSMASKVALUE, + &TestSimpleFlags64_ToggleSingleFlagValue, // OSF64_TOGGLESINGLEFLAGVALUE, + &TestSimpleFlags64_ModifySingleFlagValue, // OSF64_MODIFYSINGLEFLAGVALUE, + &TestSimpleFlags64_AssignFlagsByMask, // OSF64_ASSIGNFLAGSBYMASK, + &TestSimpleFlags64_AlterFlagsByMask, // OSF64_ALTERFLAGSBYMASK, + &TestSimpleFlags64_GetFlagsMaskValue, // OSF64_GETFLAGSMASKVALUE, + &TestSimpleFlags64_QueryFlagsByMask, // OSF64_QUERYFLAGSBYMASK, + &TestSimpleFlags64_OnlySignalSingleFlagOutOfMask, // OSF64_ONLYSIGNALSINGLEFLAGOUTOFMASK, + &TestSimpleFlags64_EnumSetEnumeratedFlagValue, // OSF64_ENUMSETENUMERATEDFLAGVALUE, + &TestSimpleFlags64_EnumSignalEnumeratedFlagValue, // OSF64_ENUMSIGNALENUMERATEDFLAGVALUE, + &TestSimpleFlags64_EnumDropEnumeratedFlagValue, // OSF64_ENUMDROPENUMERATEDFLAGVALUE, + &TestSimpleFlags64_EnumToggleEnumeratedFlagValue, // OSF64_ENUMTOGGLEENUMERATEDFLAGVALUE, + &TestSimpleFlags64_EnumModifyEnumeratedFlagValue, // OSF64_ENUMMODIFYENUMERATEDFLAGVALUE, + &TestSimpleFlags64_EnumSignalFirstEnumeratedFlagValue, // OSF64_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + &TestSimpleFlags64_EnumSignalLastEnumeratedFlagValue, // OSF64_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + &TestSimpleFlags64_EnumGetEnumeratedFlagValue, // OSF64_ENUMGETENUMERATEDFLAGVALUE, + &TestSimpleFlags64_EnumFindFirstEnumeratedFlag, // OSF64_ENUMFINDFIRSTENUMERATEDFLAG, + &TestSimpleFlags64_EnumAllSignalEnumeratedFlags, // OSF64_ENUMALLSIGNALENUMERATEDFLAGS, + &TestSimpleFlags64_EnumAllDropEnumeratedFlags, // OSF64_ENUMALLDROPENUMERATEDFLAGS, + &TestSimpleFlags64_EnumAllQueryEnumeratedFlags, // OSF64_ENUMALLQUERYENUMERATEDFLAGS, + &TestSimpleFlags64_EnumAnyGetEnumeratedFlagValue, // OSF64_ENUMANYGETENUMERATEDFLAGVALUE, + &TestSimpleFlags64_StoreFlagsEnumeratedValue, // OSF64_STOREFLAGSENUMERATEDVALUE, + &TestSimpleFlags64_RetrieveFlagsEnumeratedValue, // OSF64_RETRIEVEFLAGSENUMERATEDVALUE, +}; +static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE64, OSF64__MAX, CFeatureTestProcedure> g_afnSimpleFlags64FeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE64, OSF64__MAX, const char *>::m_aetElementArray[] = +{ + "Constructors", // OSF64_CONSTRUCTORS + "AssignFlagsAllValues", // OSF64_ASSIGNFLAGSALLVALUES, + "QueryFlagsAllValues", // OSF64_QUERYFLAGSALLVALUES, + "SetFlagsMaskValue", // OSF64_SETFLAGSMASKVALUE, + "SignalFlagsMaskValue", // OSF64_SIGNALFLAGSMASKVALUE, + "DropFlagsMaskValue", // OSF64_DROPFLAGSMASKVALUE, + "ToggleSingleFlagValue", // OSF64_TOGGLESINGLEFLAGVALUE, + "ModifySingleFlagValue", // OSF64_MODIFYSINGLEFLAGVALUE, + "AssignFlagsByMask", // OSF64_ASSIGNFLAGSBYMASK, + "AlterFlagsByMask", // OSF64_ALTERFLAGSBYMASK, + "GetFlagsMaskValue", // OSF64_GETFLAGSMASKVALUE, + "QueryFlagsByMask", // OSF64_QUERYFLAGSBYMASK, + "OnlySignalSingleFlagOutOfMask", // OSF64_ONLYSIGNALSINGLEFLAGOUTOFMASK, + "EnumSetEnumeratedFlagValue", // OSF64_ENUMSETENUMERATEDFLAGVALUE, + "EnumSignalEnumeratedFlagValue", // OSF64_ENUMSIGNALENUMERATEDFLAGVALUE, + "EnumDropEnumeratedFlagValue", // OSF64_ENUMDROPENUMERATEDFLAGVALUE, + "EnumToggleEnumeratedFlagValue", // OSF64_ENUMTOGGLEENUMERATEDFLAGVALUE, + "EnumModifyEnumeratedFlagValue", // OSF64_ENUMMODIFYENUMERATEDFLAGVALUE, + "EnumSignalFirstEnumeratedFlagValue", // OSF64_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + "EnumSignalLastEnumeratedFlagValue", // OSF64_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + "EnumGetEnumeratedFlagValue", // OSF64_ENUMGETENUMERATEDFLAGVALUE, + "EnumFindFirstEnumeratedFlag", // OSF64_ENUMFINDFIRSTENUMERATEDFLAG, + "EnumAllSignalEnumeratedFlags", // OSF64_ENUMALLSIGNALENUMERATEDFLAGS, + "EnumAllDropEnumeratedFlags", // OSF64_ENUMALLDROPENUMERATEDFLAGS, + "EnumAllQueryEnumeratedFlags", // OSF64_ENUMALLQUERYENUMERATEDFLAGS, + "EnumAnyGetEnumeratedFlagValue", // OSF64_ENUMANYGETENUMERATEDFLAGVALUE, + "StoreFlagsEnumeratedValue", // OSF64_STOREFLAGSENUMERATEDVALUE, + "RetrieveFlagsEnumeratedValue", // OSF64_RETRIEVEFLAGSENUMERATEDVALUE, +}; +static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE64, OSF64__MAX, const char *> g_aszSimpleFlags64FeatureTestNames; + + +bool TestSimpleFlags64(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OSF64__MAX, g_aszSimpleFlags64FeatureTestNames.GetStoragePointer(), g_afnSimpleFlags64FeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +typedef CSimpleFlags CSimpleFlags32; + +const uint32ou g_uiTestValue32 = (uint32ou)0xA5A5A5A5; +const uint32ou g_uiTestMask32 = (uint32ou)0xC6C6C6C6; +const uint32ou g_uiTestBit32 = (uint32ou)OU_INT32_MIN; +const uint32ou g_uiTestAnotherBit32 = (uint32ou)((uint32ou)OU_INT32_MIN >> 1); + + +bool TestSimpleFlags32_Constructors() +{ + bool bResult = false; + + do + { + if (sizeof(CSimpleFlags32::value_type) != sizeof(uint32ou) || sizeof(CSimpleFlags32) != sizeof(uint32ou)) + { + break; + } + + CSimpleFlags32 sfEmptyFlags; + + if (sfEmptyFlags.QueryFlagsAllValues()) + { + break; + } + + CSimpleFlags32 sfFullFlags(OU_UINT32_MAX); + + if (sfFullFlags.QueryFlagsAllValues() != OU_UINT32_MAX) + { + break; + } + + CSimpleFlags32 sfCopyOfFullFlags(sfFullFlags); + + if (sfCopyOfFullFlags.QueryFlagsAllValues() != OU_UINT32_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_AssignFlagsAllValues() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags; + + sfTestFlags.AssignFlagsAllValues(OU_UINT32_MAX); + + if (sfTestFlags.QueryFlagsAllValues() != OU_UINT32_MAX) + { + break; + } + + sfTestFlags.AssignFlagsAllValues(0); + + if (sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_QueryFlagsAllValues() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue32) + { + break; + } + + // Double check to be sure ;-) + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue32) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_SetFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + + sfTestFlags.SetFlagsMaskValue(g_uiTestMask32, true); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(g_uiTestValue32 | g_uiTestMask32)) + { + break; + } + + sfTestFlags.SetFlagsMaskValue(g_uiTestValue32, false); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(~g_uiTestValue32 & g_uiTestMask32)) + { + break; + } + + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_SignalFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + + sfTestFlags.SignalFlagsMaskValue(g_uiTestMask32); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(g_uiTestValue32 | g_uiTestMask32)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_DropFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + + sfTestFlags.DropFlagsMaskValue(g_uiTestMask32); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(g_uiTestValue32 & ~g_uiTestMask32)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_ToggleSingleFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + + bool bPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit32); + + if (bPreviousValue != ((g_uiTestValue32 & g_uiTestBit32) != 0) || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(g_uiTestValue32 ^ g_uiTestBit32)) + { + break; + } + + bool bAnotherPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit32); + + if (bAnotherPreviousValue == bPreviousValue || sfTestFlags.QueryFlagsAllValues() != g_uiTestValue32) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_ModifySingleFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + + bool bFirstModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit32, true); + + if (bFirstModification != ((g_uiTestValue32 & g_uiTestBit32) != g_uiTestBit32) || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(g_uiTestValue32 | g_uiTestBit32)) + { + break; + } + + bool bAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit32, bFirstModification); + + if (bAnotherModification == bFirstModification || sfTestFlags.QueryFlagsAllValues() != (bFirstModification ? (uint32ou)(g_uiTestValue32 | g_uiTestBit32) : (uint32ou)(g_uiTestValue32 & ~g_uiTestBit32))) + { + break; + } + + bool bYetAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit32, bAnotherModification); + + if (bYetAnotherModification != bAnotherModification || sfTestFlags.QueryFlagsAllValues() != (bAnotherModification ? (uint32ou)(g_uiTestValue32 | g_uiTestBit32) : (uint32ou)(g_uiTestValue32 & ~g_uiTestBit32))) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_AssignFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + + uint32ou uiPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask32, g_uiTestMask32); + + const uint32ou uiNewFlags = (g_uiTestValue32 & ~g_uiTestMask32) | g_uiTestMask32; + + if (uiPreviousFlags != g_uiTestValue32 || sfTestFlags.QueryFlagsAllValues() != uiNewFlags) + { + break; + } + + uint32ou uiAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestValue32, 0); + + const uint32ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue32; + + if (uiAnotherPreviousFlags != uiNewFlags || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + uint32ou uiYetAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask32, g_uiTestMask32 & g_uiTestValue32); + OU_ASSERT((g_uiTestMask32 & g_uiTestValue32) != 0); // Test degeneration + + const uint32ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask32) | (g_uiTestMask32 & g_uiTestValue32); + OU_ASSERT(uiYetAnotherNewFlags != OU_UINT32_MAX); // Test degeneration + + if (uiYetAnotherPreviousFlags != uiAnotherNewFlags || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_AlterFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + + bool bWasModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask32, g_uiTestMask32); + + const uint32ou uiNewFlags = (g_uiTestValue32 & ~g_uiTestMask32) | g_uiTestMask32; + + if (bWasModification != ((g_uiTestValue32 & g_uiTestMask32) != g_uiTestMask32) || sfTestFlags.QueryFlagsAllValues() != uiNewFlags) + { + break; + } + + bool bWasAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestValue32, 0); + + const uint32ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue32; + + if (bWasAnotherModification != ((uiNewFlags & g_uiTestValue32) != 0) || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + bool bWasAnotherModificationRepeated = sfTestFlags.AlterFlagsByMask(g_uiTestValue32, 0); + + if (bWasAnotherModificationRepeated || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + bool bWasYetAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask32, g_uiTestMask32 & g_uiTestValue32); + OU_ASSERT((g_uiTestMask32 & g_uiTestValue32) != 0); // Test degeneration + + const uint32ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask32) | (g_uiTestMask32 & g_uiTestValue32); + OU_ASSERT(uiYetAnotherNewFlags != OU_UINT32_MAX); // Test degeneration + + if (bWasYetAnotherModification != ((uiAnotherNewFlags & g_uiTestMask32) != (g_uiTestMask32 & g_uiTestValue32)) || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_GetFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + + if (sfTestFlags.GetFlagsMaskValue(g_uiTestMask32) != ((g_uiTestValue32 & g_uiTestMask32) != 0)) + { + break; + } + + if (sfTestFlags.GetFlagsMaskValue(~g_uiTestValue32)) + { + break; + } + + if (!sfTestFlags.GetFlagsMaskValue(OU_UINT32_MAX)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_QueryFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + + if (sfTestFlags.QueryFlagsByMask(g_uiTestMask32) != (uint32ou)(g_uiTestValue32 & g_uiTestMask32)) + { + break; + } + + if (sfTestFlags.QueryFlagsByMask(0)) + { + break; + } + + if (sfTestFlags.QueryFlagsByMask(OU_UINT32_MAX) != g_uiTestValue32) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_OnlySignalSingleFlagOutOfMask() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(g_uiTestValue32); + OU_ASSERT(g_uiTestValue32 != 0); // Test degeneration + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT32_MAX, g_uiTestBit32)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue32) + { + break; + } + + sfTestFlags.AssignFlagsAllValues(0); + + if (!sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit32, g_uiTestBit32)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit32) + { + break; + } + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit32, g_uiTestBit32)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit32) + { + break; + } + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT32_MAX, g_uiTestAnotherBit32)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit32) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumSetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags; + + sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT32_BITS, false); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)OU_INT32_MIN) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, false); + + if (sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumSignalEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags; + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumDropEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(OU_UINT32_MAX); + + sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (OU_UINT32_MAX ^ 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)~(OU_INT32_MIN + 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)~(OU_INT32_MIN + 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)~(OU_INT32_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumToggleEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags; + + bool bToggleFirstResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (bToggleFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bToggleSecondResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (bToggleSecondResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1)) + { + break; + } + + bool bToggleThirdResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (!bToggleThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)OU_INT32_MIN) + { + break; + } + + bool bToggleFourthResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (!bToggleFourthResult || sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumModifyEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags; + + bool bModifyFirstResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true); + + if (!bModifyFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bModifySecondResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true); + + if (!bModifySecondResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1)) + { + break; + } + + bool bModifyThirdResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, true); + + if (bModifyThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1)) + { + break; + } + + bool bModifyFourthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, true); + + if (bModifyFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 1)) + { + break; + } + + bool bModifyFifthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT32_BITS, false); + + if (!bModifyFifthResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)OU_INT32_MIN) + { + break; + } + + bool bModifySixthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS, false); + + if (!bModifySixthResult || sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumSignalFirstEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags; + + bool bFirstResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT32_BITS); + + if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(2, 0, OU_UINT32_BITS - 1); + + if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3) + { + break; + } + + bool bFourthResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 3)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumSignalLastEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags; + + bool bFirstResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1); + + if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1); + + if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 1, 2); + + if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3) + { + break; + } + + bool bFourthResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS); + + if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_INT32_MIN + 3)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumGetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags((uint32ou)(OU_INT32_MIN + 1)); + + if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, 0, OU_UINT32_BITS)) + { + break; + } + + if (sfTestFlags.EnumGetEnumeratedFlagValue(2, 0, OU_UINT32_BITS - 1)) + { + break; + } + + if (sfTestFlags.EnumGetEnumeratedFlagValue(1, 1, OU_UINT32_BITS - 1)) + { + break; + } + + if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, OU_UINT32_BITS - 1, OU_UINT32_BITS)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumFindFirstEnumeratedFlag() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags((uint32ou)(OU_INT32_MIN + 1)); + + unsigned int uiFirstResult = sfTestFlags.EnumFindFirstEnumeratedFlag(1, OU_UINT32_BITS); + if (uiFirstResult != 0) + { + break; + } + + unsigned int uiSecondResult = sfTestFlags.EnumFindFirstEnumeratedFlag(2, OU_UINT32_BITS - 1); + if (uiSecondResult != OU_UINT32_BITS - 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumAllSignalEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags; + + sfTestFlags.EnumAllSignalEnumeratedFlags(1, 1); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumAllSignalEnumeratedFlags(4, OU_UINT32_BITS - 2); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_UINT32_MAX ^ 2)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumAllDropEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags(OU_UINT32_MAX); + + sfTestFlags.EnumAllDropEnumeratedFlags(1, 1); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(OU_UINT32_MAX ^ 1)) + { + break; + } + + sfTestFlags.EnumAllDropEnumeratedFlags(4, OU_UINT32_BITS - 2); + + if (sfTestFlags.QueryFlagsAllValues() != 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumAllQueryEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags((uint32ou)(OU_INT32_MIN + 1)); + + uint32ou uiFirstResult = sfTestFlags.EnumAllQueryEnumeratedFlags(1, OU_UINT32_BITS); + if (uiFirstResult != (uint32ou)(OU_INT32_MIN + 1)) + { + break; + } + + uint32ou uiSecondResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT32_BITS - 1); + if (uiSecondResult != (uint32ou)(OU_INT32_MIN)) + { + break; + } + + uint32ou uiThirdResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT32_BITS - 2); + if (uiThirdResult != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_EnumAnyGetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags((uint32ou)(OU_INT32_MIN + 1)); + + bool bFirstResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(1, OU_UINT32_BITS); + if (!bFirstResult) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT32_BITS - 1); + if (!bSecondResult) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT32_BITS - 2); + if (bThirdResult) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_StoreFlagsEnumeratedValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags; + + sfTestFlags.StoreFlagsEnumeratedValue(0x03, 1, 2); + + if (sfTestFlags.QueryFlagsAllValues() != (uint32ou)(2 << 1)) + { + break; + } + + sfTestFlags.StoreFlagsEnumeratedValue(0x03, OU_UINT32_BITS - 2, 3); + + if (sfTestFlags.QueryFlagsAllValues() != ((uint32ou)(2 << 1) | (uint32ou)(OU_INT32_MIN | (OU_INT32_MIN >> 1)))) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags32_RetrieveFlagsEnumeratedValue() +{ + bool bResult = false; + + do + { + CSimpleFlags32 sfTestFlags((uint32ou)(OU_INT32_MIN + 1)); + + unsigned int uiFirstResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, 1); + if (uiFirstResult != 0) + { + break; + } + + unsigned int uiSecondResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, OU_UINT32_BITS - 2); + if (uiSecondResult != 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUSIMPLEFLAGSFEATURE32 +{ + OSF32__MIN, + + OSF32_CONSTRUCTORS = OSF32__MIN, + OSF32_ASSIGNFLAGSALLVALUES, + OSF32_QUERYFLAGSALLVALUES, + OSF32_SETFLAGSMASKVALUE, + OSF32_SIGNALFLAGSMASKVALUE, + OSF32_DROPFLAGSMASKVALUE, + OSF32_TOGGLESINGLEFLAGVALUE, + OSF32_MODIFYSINGLEFLAGVALUE, + OSF32_ASSIGNFLAGSBYMASK, + OSF32_ALTERFLAGSBYMASK, + OSF32_GETFLAGSMASKVALUE, + OSF32_QUERYFLAGSBYMASK, + OSF32_ONLYSIGNALSINGLEFLAGOUTOFMASK, + OSF32_ENUMSETENUMERATEDFLAGVALUE, + OSF32_ENUMSIGNALENUMERATEDFLAGVALUE, + OSF32_ENUMDROPENUMERATEDFLAGVALUE, + OSF32_ENUMTOGGLEENUMERATEDFLAGVALUE, + OSF32_ENUMMODIFYENUMERATEDFLAGVALUE, + OSF32_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + OSF32_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + OSF32_ENUMGETENUMERATEDFLAGVALUE, + OSF32_ENUMFINDFIRSTENUMERATEDFLAG, + OSF32_ENUMALLSIGNALENUMERATEDFLAGS, + OSF32_ENUMALLDROPENUMERATEDFLAGS, + OSF32_ENUMALLQUERYENUMERATEDFLAGS, + OSF32_ENUMANYGETENUMERATEDFLAGVALUE, + OSF32_STOREFLAGSENUMERATEDVALUE, + OSF32_RETRIEVEFLAGSENUMERATEDVALUE, + + OSF32__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE32, OSF32__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestSimpleFlags32_Constructors, // OSF32_CONSTRUCTORS + &TestSimpleFlags32_AssignFlagsAllValues, // OSF32_ASSIGNFLAGSALLVALUES, + &TestSimpleFlags32_QueryFlagsAllValues, // OSF32_QUERYFLAGSALLVALUES, + &TestSimpleFlags32_SetFlagsMaskValue, // OSF32_SETFLAGSMASKVALUE, + &TestSimpleFlags32_SignalFlagsMaskValue, // OSF32_SIGNALFLAGSMASKVALUE, + &TestSimpleFlags32_DropFlagsMaskValue, // OSF32_DROPFLAGSMASKVALUE, + &TestSimpleFlags32_ToggleSingleFlagValue, // OSF32_TOGGLESINGLEFLAGVALUE, + &TestSimpleFlags32_ModifySingleFlagValue, // OSF32_MODIFYSINGLEFLAGVALUE, + &TestSimpleFlags32_AssignFlagsByMask, // OSF32_ASSIGNFLAGSBYMASK, + &TestSimpleFlags32_AlterFlagsByMask, // OSF32_ALTERFLAGSBYMASK, + &TestSimpleFlags32_GetFlagsMaskValue, // OSF32_GETFLAGSMASKVALUE, + &TestSimpleFlags32_QueryFlagsByMask, // OSF32_QUERYFLAGSBYMASK, + &TestSimpleFlags32_OnlySignalSingleFlagOutOfMask, // OSF32_ONLYSIGNALSINGLEFLAGOUTOFMASK, + &TestSimpleFlags32_EnumSetEnumeratedFlagValue, // OSF32_ENUMSETENUMERATEDFLAGVALUE, + &TestSimpleFlags32_EnumSignalEnumeratedFlagValue, // OSF32_ENUMSIGNALENUMERATEDFLAGVALUE, + &TestSimpleFlags32_EnumDropEnumeratedFlagValue, // OSF32_ENUMDROPENUMERATEDFLAGVALUE, + &TestSimpleFlags32_EnumToggleEnumeratedFlagValue, // OSF32_ENUMTOGGLEENUMERATEDFLAGVALUE, + &TestSimpleFlags32_EnumModifyEnumeratedFlagValue, // OSF32_ENUMMODIFYENUMERATEDFLAGVALUE, + &TestSimpleFlags32_EnumSignalFirstEnumeratedFlagValue, // OSF32_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + &TestSimpleFlags32_EnumSignalLastEnumeratedFlagValue, // OSF32_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + &TestSimpleFlags32_EnumGetEnumeratedFlagValue, // OSF32_ENUMGETENUMERATEDFLAGVALUE, + &TestSimpleFlags32_EnumFindFirstEnumeratedFlag, // OSF32_ENUMFINDFIRSTENUMERATEDFLAG, + &TestSimpleFlags32_EnumAllSignalEnumeratedFlags, // OSF32_ENUMALLSIGNALENUMERATEDFLAGS, + &TestSimpleFlags32_EnumAllDropEnumeratedFlags, // OSF32_ENUMALLDROPENUMERATEDFLAGS, + &TestSimpleFlags32_EnumAllQueryEnumeratedFlags, // OSF32_ENUMALLQUERYENUMERATEDFLAGS, + &TestSimpleFlags32_EnumAnyGetEnumeratedFlagValue, // OSF32_ENUMANYGETENUMERATEDFLAGVALUE, + &TestSimpleFlags32_StoreFlagsEnumeratedValue, // OSF32_STOREFLAGSENUMERATEDVALUE, + &TestSimpleFlags32_RetrieveFlagsEnumeratedValue, // OSF32_RETRIEVEFLAGSENUMERATEDVALUE, +}; +static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE32, OSF32__MAX, CFeatureTestProcedure> g_afnSimpleFlags32FeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE32, OSF32__MAX, const char *>::m_aetElementArray[] = +{ + "Constructors", // OSF32_CONSTRUCTORS + "AssignFlagsAllValues", // OSF32_ASSIGNFLAGSALLVALUES, + "QueryFlagsAllValues", // OSF32_QUERYFLAGSALLVALUES, + "SetFlagsMaskValue", // OSF32_SETFLAGSMASKVALUE, + "SignalFlagsMaskValue", // OSF32_SIGNALFLAGSMASKVALUE, + "DropFlagsMaskValue", // OSF32_DROPFLAGSMASKVALUE, + "ToggleSingleFlagValue", // OSF32_TOGGLESINGLEFLAGVALUE, + "ModifySingleFlagValue", // OSF32_MODIFYSINGLEFLAGVALUE, + "AssignFlagsByMask", // OSF32_ASSIGNFLAGSBYMASK, + "AlterFlagsByMask", // OSF32_ALTERFLAGSBYMASK, + "GetFlagsMaskValue", // OSF32_GETFLAGSMASKVALUE, + "QueryFlagsByMask", // OSF32_QUERYFLAGSBYMASK, + "OnlySignalSingleFlagOutOfMask", // OSF32_ONLYSIGNALSINGLEFLAGOUTOFMASK, + "EnumSetEnumeratedFlagValue", // OSF32_ENUMSETENUMERATEDFLAGVALUE, + "EnumSignalEnumeratedFlagValue", // OSF32_ENUMSIGNALENUMERATEDFLAGVALUE, + "EnumDropEnumeratedFlagValue", // OSF32_ENUMDROPENUMERATEDFLAGVALUE, + "EnumToggleEnumeratedFlagValue", // OSF32_ENUMTOGGLEENUMERATEDFLAGVALUE, + "EnumModifyEnumeratedFlagValue", // OSF32_ENUMMODIFYENUMERATEDFLAGVALUE, + "EnumSignalFirstEnumeratedFlagValue", // OSF32_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + "EnumSignalLastEnumeratedFlagValue", // OSF32_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + "EnumGetEnumeratedFlagValue", // OSF32_ENUMGETENUMERATEDFLAGVALUE, + "EnumFindFirstEnumeratedFlag", // OSF32_ENUMFINDFIRSTENUMERATEDFLAG, + "EnumAllSignalEnumeratedFlags", // OSF32_ENUMALLSIGNALENUMERATEDFLAGS, + "EnumAllDropEnumeratedFlags", // OSF32_ENUMALLDROPENUMERATEDFLAGS, + "EnumAllQueryEnumeratedFlags", // OSF32_ENUMALLQUERYENUMERATEDFLAGS, + "EnumAnyGetEnumeratedFlagValue", // OSF32_ENUMANYGETENUMERATEDFLAGVALUE, + "StoreFlagsEnumeratedValue", // OSF32_STOREFLAGSENUMERATEDVALUE, + "RetrieveFlagsEnumeratedValue", // OSF32_RETRIEVEFLAGSENUMERATEDVALUE, +}; +static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE32, OSF32__MAX, const char *> g_aszSimpleFlags32FeatureTestNames; + + +bool TestSimpleFlags32(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OSF32__MAX, g_aszSimpleFlags32FeatureTestNames.GetStoragePointer(), g_afnSimpleFlags32FeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +typedef CSimpleFlagsTemplate<uint16ou> CSimpleFlags16; + +const uint16ou g_uiTestValue16 = (uint16ou)0xA5A5; +const uint16ou g_uiTestMask16 = (uint16ou)0xC6C6; +const uint16ou g_uiTestBit16 = (uint16ou)OU_INT16_MIN; +const uint16ou g_uiTestAnotherBit16 = (uint16ou)((uint16ou)OU_INT16_MIN >> 1); + + +bool TestSimpleFlags16_Constructors() +{ + bool bResult = false; + + do + { + if (sizeof(CSimpleFlags16::value_type) != sizeof(uint16ou) || sizeof(CSimpleFlags16) != sizeof(uint16ou)) + { + break; + } + + CSimpleFlags16 sfEmptyFlags; + + if (sfEmptyFlags.QueryFlagsAllValues()) + { + break; + } + + CSimpleFlags16 sfFullFlags(OU_UINT16_MAX); + + if (sfFullFlags.QueryFlagsAllValues() != OU_UINT16_MAX) + { + break; + } + + CSimpleFlags16 sfCopyOfFullFlags(sfFullFlags); + + if (sfCopyOfFullFlags.QueryFlagsAllValues() != OU_UINT16_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_AssignFlagsAllValues() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags; + + sfTestFlags.AssignFlagsAllValues(OU_UINT16_MAX); + + if (sfTestFlags.QueryFlagsAllValues() != OU_UINT16_MAX) + { + break; + } + + sfTestFlags.AssignFlagsAllValues(0); + + if (sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_QueryFlagsAllValues() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue16) + { + break; + } + + // Double check to be sure ;-) + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue16) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_SetFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + + sfTestFlags.SetFlagsMaskValue(g_uiTestMask16, true); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(g_uiTestValue16 | g_uiTestMask16)) + { + break; + } + + sfTestFlags.SetFlagsMaskValue(g_uiTestValue16, false); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(~g_uiTestValue16 & g_uiTestMask16)) + { + break; + } + + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_SignalFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + + sfTestFlags.SignalFlagsMaskValue(g_uiTestMask16); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(g_uiTestValue16 | g_uiTestMask16)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_DropFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + + sfTestFlags.DropFlagsMaskValue(g_uiTestMask16); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(g_uiTestValue16 & ~g_uiTestMask16)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_ToggleSingleFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + + bool bPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit16); + + if (bPreviousValue != ((g_uiTestValue16 & g_uiTestBit16) != 0) || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(g_uiTestValue16 ^ g_uiTestBit16)) + { + break; + } + + bool bAnotherPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit16); + + if (bAnotherPreviousValue == bPreviousValue || sfTestFlags.QueryFlagsAllValues() != g_uiTestValue16) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_ModifySingleFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + + bool bFirstModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit16, true); + + if (bFirstModification != ((g_uiTestValue16 & g_uiTestBit16) != g_uiTestBit16) || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(g_uiTestValue16 | g_uiTestBit16)) + { + break; + } + + bool bAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit16, bFirstModification); + + if (bAnotherModification == bFirstModification || sfTestFlags.QueryFlagsAllValues() != (bFirstModification ? (uint16ou)(g_uiTestValue16 | g_uiTestBit16) : (uint16ou)(g_uiTestValue16 & ~g_uiTestBit16))) + { + break; + } + + bool bYetAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit16, bAnotherModification); + + if (bYetAnotherModification != bAnotherModification || sfTestFlags.QueryFlagsAllValues() != (bAnotherModification ? (uint16ou)(g_uiTestValue16 | g_uiTestBit16) : (uint16ou)(g_uiTestValue16 & ~g_uiTestBit16))) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_AssignFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + + uint16ou uiPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask16, g_uiTestMask16); + + const uint16ou uiNewFlags = (g_uiTestValue16 & ~g_uiTestMask16) | g_uiTestMask16; + + if (uiPreviousFlags != g_uiTestValue16 || sfTestFlags.QueryFlagsAllValues() != uiNewFlags) + { + break; + } + + uint16ou uiAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestValue16, 0); + + const uint16ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue16; + + if (uiAnotherPreviousFlags != uiNewFlags || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + uint16ou uiYetAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask16, g_uiTestMask16 & g_uiTestValue16); + OU_ASSERT((g_uiTestMask16 & g_uiTestValue16) != 0); // Test degeneration + + const uint16ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask16) | (g_uiTestMask16 & g_uiTestValue16); + OU_ASSERT(uiYetAnotherNewFlags != OU_UINT16_MAX); // Test degeneration + + if (uiYetAnotherPreviousFlags != uiAnotherNewFlags || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_AlterFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + + bool bWasModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask16, g_uiTestMask16); + + const uint16ou uiNewFlags = (g_uiTestValue16 & ~g_uiTestMask16) | g_uiTestMask16; + + if (bWasModification != ((g_uiTestValue16 & g_uiTestMask16) != g_uiTestMask16) || sfTestFlags.QueryFlagsAllValues() != uiNewFlags) + { + break; + } + + bool bWasAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestValue16, 0); + + const uint16ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue16; + + if (bWasAnotherModification != ((uiNewFlags & g_uiTestValue16) != 0) || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + bool bWasAnotherModificationRepeated = sfTestFlags.AlterFlagsByMask(g_uiTestValue16, 0); + + if (bWasAnotherModificationRepeated || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + bool bWasYetAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask16, g_uiTestMask16 & g_uiTestValue16); + OU_ASSERT((g_uiTestMask16 & g_uiTestValue16) != 0); // Test degeneration + + const uint16ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask16) | (g_uiTestMask16 & g_uiTestValue16); + OU_ASSERT(uiYetAnotherNewFlags != OU_UINT16_MAX); // Test degeneration + + if (bWasYetAnotherModification != ((uiAnotherNewFlags & g_uiTestMask16) != (g_uiTestMask16 & g_uiTestValue16)) || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_GetFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + + if (sfTestFlags.GetFlagsMaskValue(g_uiTestMask16) != ((g_uiTestValue16 & g_uiTestMask16) != 0)) + { + break; + } + + if (sfTestFlags.GetFlagsMaskValue((uint16ou)(~g_uiTestValue16))) + { + break; + } + + if (!sfTestFlags.GetFlagsMaskValue(OU_UINT16_MAX)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_QueryFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + + if (sfTestFlags.QueryFlagsByMask(g_uiTestMask16) != (uint16ou)(g_uiTestValue16 & g_uiTestMask16)) + { + break; + } + + if (sfTestFlags.QueryFlagsByMask(0)) + { + break; + } + + if (sfTestFlags.QueryFlagsByMask(OU_UINT16_MAX) != g_uiTestValue16) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_OnlySignalSingleFlagOutOfMask() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(g_uiTestValue16); + OU_ASSERT(g_uiTestValue16 != 0); // Test degeneration + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT16_MAX, g_uiTestBit16)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue16) + { + break; + } + + sfTestFlags.AssignFlagsAllValues(0); + + if (!sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit16, g_uiTestBit16)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit16) + { + break; + } + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit16, g_uiTestBit16)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit16) + { + break; + } + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT16_MAX, g_uiTestAnotherBit16)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit16) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumSetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags; + + sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT16_BITS, true); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS, true); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT16_BITS, false); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)OU_INT16_MIN) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS, false); + + if (sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumSignalEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags; + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT16_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT16_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumDropEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(OU_UINT16_MAX); + + sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT16_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (OU_UINT16_MAX ^ 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)~(OU_INT16_MIN + 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT16_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)~(OU_INT16_MIN + 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)~(OU_INT16_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumToggleEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags; + + bool bToggleFirstResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT16_BITS); + + if (bToggleFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bToggleSecondResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS); + + if (bToggleSecondResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1)) + { + break; + } + + bool bToggleThirdResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT16_BITS); + + if (!bToggleThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)OU_INT16_MIN) + { + break; + } + + bool bToggleFourthResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS); + + if (!bToggleFourthResult || sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumModifyEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags; + + bool bModifyFirstResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT16_BITS, true); + + if (!bModifyFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bModifySecondResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS, true); + + if (!bModifySecondResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1)) + { + break; + } + + bool bModifyThirdResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT16_BITS, true); + + if (bModifyThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1)) + { + break; + } + + bool bModifyFourthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS, true); + + if (bModifyFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 1)) + { + break; + } + + bool bModifyFifthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT16_BITS, false); + + if (!bModifyFifthResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)OU_INT16_MIN) + { + break; + } + + bool bModifySixthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS, false); + + if (!bModifySixthResult || sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumSignalFirstEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags; + + bool bFirstResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT16_BITS); + + if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT16_BITS); + + if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(2, 0, OU_UINT16_BITS - 1); + + if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3) + { + break; + } + + bool bFourthResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS); + + if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 3)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumSignalLastEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags; + + bool bFirstResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1); + + if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1); + + if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 1, 2); + + if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3) + { + break; + } + + bool bFourthResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS); + + if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_INT16_MIN + 3)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumGetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags((uint16ou)(OU_INT16_MIN + 1)); + + if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, 0, OU_UINT16_BITS)) + { + break; + } + + if (sfTestFlags.EnumGetEnumeratedFlagValue(2, 0, OU_UINT16_BITS - 1)) + { + break; + } + + if (sfTestFlags.EnumGetEnumeratedFlagValue(1, 1, OU_UINT16_BITS - 1)) + { + break; + } + + if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, OU_UINT16_BITS - 1, OU_UINT16_BITS)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumFindFirstEnumeratedFlag() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags((uint16ou)(OU_INT16_MIN + 1)); + + unsigned int uiFirstResult = sfTestFlags.EnumFindFirstEnumeratedFlag(1, OU_UINT16_BITS); + if (uiFirstResult != 0) + { + break; + } + + unsigned int uiSecondResult = sfTestFlags.EnumFindFirstEnumeratedFlag(2, OU_UINT16_BITS - 1); + if (uiSecondResult != OU_UINT16_BITS - 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumAllSignalEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags; + + sfTestFlags.EnumAllSignalEnumeratedFlags(1, 1); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumAllSignalEnumeratedFlags(4, OU_UINT16_BITS - 2); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_UINT16_MAX ^ 2)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumAllDropEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags(OU_UINT16_MAX); + + sfTestFlags.EnumAllDropEnumeratedFlags(1, 1); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(OU_UINT16_MAX ^ 1)) + { + break; + } + + sfTestFlags.EnumAllDropEnumeratedFlags(4, OU_UINT16_BITS - 2); + + if (sfTestFlags.QueryFlagsAllValues() != 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumAllQueryEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags((uint16ou)(OU_INT16_MIN + 1)); + + uint16ou uiFirstResult = sfTestFlags.EnumAllQueryEnumeratedFlags(1, OU_UINT16_BITS); + if (uiFirstResult != (uint16ou)(OU_INT16_MIN + 1)) + { + break; + } + + uint16ou uiSecondResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT16_BITS - 1); + if (uiSecondResult != (uint16ou)(OU_INT16_MIN)) + { + break; + } + + uint16ou uiThirdResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT16_BITS - 2); + if (uiThirdResult != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_EnumAnyGetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags((uint16ou)(OU_INT16_MIN + 1)); + + bool bFirstResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(1, OU_UINT16_BITS); + if (!bFirstResult) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT16_BITS - 1); + if (!bSecondResult) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT16_BITS - 2); + if (bThirdResult) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_StoreFlagsEnumeratedValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags; + + sfTestFlags.StoreFlagsEnumeratedValue(0x03, 1, 2); + + if (sfTestFlags.QueryFlagsAllValues() != (uint16ou)(2 << 1)) + { + break; + } + + sfTestFlags.StoreFlagsEnumeratedValue(0x03, OU_UINT16_BITS - 2, 3); + + if (sfTestFlags.QueryFlagsAllValues() != ((uint16ou)(2 << 1) | (uint16ou)(OU_INT16_MIN | (OU_INT16_MIN >> 1)))) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags16_RetrieveFlagsEnumeratedValue() +{ + bool bResult = false; + + do + { + CSimpleFlags16 sfTestFlags((uint16ou)(OU_INT16_MIN + 1)); + + unsigned int uiFirstResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, 1); + if (uiFirstResult != 0) + { + break; + } + + unsigned int uiSecondResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, OU_UINT16_BITS - 2); + if (uiSecondResult != 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUSIMPLEFLAGSFEATURE16 +{ + OSF16__MIN, + + OSF16_CONSTRUCTORS = OSF16__MIN, + OSF16_ASSIGNFLAGSALLVALUES, + OSF16_QUERYFLAGSALLVALUES, + OSF16_SETFLAGSMASKVALUE, + OSF16_SIGNALFLAGSMASKVALUE, + OSF16_DROPFLAGSMASKVALUE, + OSF16_TOGGLESINGLEFLAGVALUE, + OSF16_MODIFYSINGLEFLAGVALUE, + OSF16_ASSIGNFLAGSBYMASK, + OSF16_ALTERFLAGSBYMASK, + OSF16_GETFLAGSMASKVALUE, + OSF16_QUERYFLAGSBYMASK, + OSF16_ONLYSIGNALSINGLEFLAGOUTOFMASK, + OSF16_ENUMSETENUMERATEDFLAGVALUE, + OSF16_ENUMSIGNALENUMERATEDFLAGVALUE, + OSF16_ENUMDROPENUMERATEDFLAGVALUE, + OSF16_ENUMTOGGLEENUMERATEDFLAGVALUE, + OSF16_ENUMMODIFYENUMERATEDFLAGVALUE, + OSF16_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + OSF16_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + OSF16_ENUMGETENUMERATEDFLAGVALUE, + OSF16_ENUMFINDFIRSTENUMERATEDFLAG, + OSF16_ENUMALLSIGNALENUMERATEDFLAGS, + OSF16_ENUMALLDROPENUMERATEDFLAGS, + OSF16_ENUMALLQUERYENUMERATEDFLAGS, + OSF16_ENUMANYGETENUMERATEDFLAGVALUE, + OSF16_STOREFLAGSENUMERATEDVALUE, + OSF16_RETRIEVEFLAGSENUMERATEDVALUE, + + OSF16__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE16, OSF16__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestSimpleFlags16_Constructors, // OSF16_CONSTRUCTORS + &TestSimpleFlags16_AssignFlagsAllValues, // OSF16_ASSIGNFLAGSALLVALUES, + &TestSimpleFlags16_QueryFlagsAllValues, // OSF16_QUERYFLAGSALLVALUES, + &TestSimpleFlags16_SetFlagsMaskValue, // OSF16_SETFLAGSMASKVALUE, + &TestSimpleFlags16_SignalFlagsMaskValue, // OSF16_SIGNALFLAGSMASKVALUE, + &TestSimpleFlags16_DropFlagsMaskValue, // OSF16_DROPFLAGSMASKVALUE, + &TestSimpleFlags16_ToggleSingleFlagValue, // OSF16_TOGGLESINGLEFLAGVALUE, + &TestSimpleFlags16_ModifySingleFlagValue, // OSF16_MODIFYSINGLEFLAGVALUE, + &TestSimpleFlags16_AssignFlagsByMask, // OSF16_ASSIGNFLAGSBYMASK, + &TestSimpleFlags16_AlterFlagsByMask, // OSF16_ALTERFLAGSBYMASK, + &TestSimpleFlags16_GetFlagsMaskValue, // OSF16_GETFLAGSMASKVALUE, + &TestSimpleFlags16_QueryFlagsByMask, // OSF16_QUERYFLAGSBYMASK, + &TestSimpleFlags16_OnlySignalSingleFlagOutOfMask, // OSF16_ONLYSIGNALSINGLEFLAGOUTOFMASK, + &TestSimpleFlags16_EnumSetEnumeratedFlagValue, // OSF16_ENUMSETENUMERATEDFLAGVALUE, + &TestSimpleFlags16_EnumSignalEnumeratedFlagValue, // OSF16_ENUMSIGNALENUMERATEDFLAGVALUE, + &TestSimpleFlags16_EnumDropEnumeratedFlagValue, // OSF16_ENUMDROPENUMERATEDFLAGVALUE, + &TestSimpleFlags16_EnumToggleEnumeratedFlagValue, // OSF16_ENUMTOGGLEENUMERATEDFLAGVALUE, + &TestSimpleFlags16_EnumModifyEnumeratedFlagValue, // OSF16_ENUMMODIFYENUMERATEDFLAGVALUE, + &TestSimpleFlags16_EnumSignalFirstEnumeratedFlagValue, // OSF16_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + &TestSimpleFlags16_EnumSignalLastEnumeratedFlagValue, // OSF16_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + &TestSimpleFlags16_EnumGetEnumeratedFlagValue, // OSF16_ENUMGETENUMERATEDFLAGVALUE, + &TestSimpleFlags16_EnumFindFirstEnumeratedFlag, // OSF16_ENUMFINDFIRSTENUMERATEDFLAG, + &TestSimpleFlags16_EnumAllSignalEnumeratedFlags, // OSF16_ENUMALLSIGNALENUMERATEDFLAGS, + &TestSimpleFlags16_EnumAllDropEnumeratedFlags, // OSF16_ENUMALLDROPENUMERATEDFLAGS, + &TestSimpleFlags16_EnumAllQueryEnumeratedFlags, // OSF16_ENUMALLQUERYENUMERATEDFLAGS, + &TestSimpleFlags16_EnumAnyGetEnumeratedFlagValue, // OSF16_ENUMANYGETENUMERATEDFLAGVALUE, + &TestSimpleFlags16_StoreFlagsEnumeratedValue, // OSF16_STOREFLAGSENUMERATEDVALUE, + &TestSimpleFlags16_RetrieveFlagsEnumeratedValue, // OSF16_RETRIEVEFLAGSENUMERATEDVALUE, +}; +static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE16, OSF16__MAX, CFeatureTestProcedure> g_afnSimpleFlags16FeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE16, OSF16__MAX, const char *>::m_aetElementArray[] = +{ + "Constructors", // OSF16_CONSTRUCTORS + "AssignFlagsAllValues", // OSF16_ASSIGNFLAGSALLVALUES, + "QueryFlagsAllValues", // OSF16_QUERYFLAGSALLVALUES, + "SetFlagsMaskValue", // OSF16_SETFLAGSMASKVALUE, + "SignalFlagsMaskValue", // OSF16_SIGNALFLAGSMASKVALUE, + "DropFlagsMaskValue", // OSF16_DROPFLAGSMASKVALUE, + "ToggleSingleFlagValue", // OSF16_TOGGLESINGLEFLAGVALUE, + "ModifySingleFlagValue", // OSF16_MODIFYSINGLEFLAGVALUE, + "AssignFlagsByMask", // OSF16_ASSIGNFLAGSBYMASK, + "AlterFlagsByMask", // OSF16_ALTERFLAGSBYMASK, + "GetFlagsMaskValue", // OSF16_GETFLAGSMASKVALUE, + "QueryFlagsByMask", // OSF16_QUERYFLAGSBYMASK, + "OnlySignalSingleFlagOutOfMask", // OSF16_ONLYSIGNALSINGLEFLAGOUTOFMASK, + "EnumSetEnumeratedFlagValue", // OSF16_ENUMSETENUMERATEDFLAGVALUE, + "EnumSignalEnumeratedFlagValue", // OSF16_ENUMSIGNALENUMERATEDFLAGVALUE, + "EnumDropEnumeratedFlagValue", // OSF16_ENUMDROPENUMERATEDFLAGVALUE, + "EnumToggleEnumeratedFlagValue", // OSF16_ENUMTOGGLEENUMERATEDFLAGVALUE, + "EnumModifyEnumeratedFlagValue", // OSF16_ENUMMODIFYENUMERATEDFLAGVALUE, + "EnumSignalFirstEnumeratedFlagValue", // OSF16_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + "EnumSignalLastEnumeratedFlagValue", // OSF16_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + "EnumGetEnumeratedFlagValue", // OSF16_ENUMGETENUMERATEDFLAGVALUE, + "EnumFindFirstEnumeratedFlag", // OSF16_ENUMFINDFIRSTENUMERATEDFLAG, + "EnumAllSignalEnumeratedFlags", // OSF16_ENUMALLSIGNALENUMERATEDFLAGS, + "EnumAllDropEnumeratedFlags", // OSF16_ENUMALLDROPENUMERATEDFLAGS, + "EnumAllQueryEnumeratedFlags", // OSF16_ENUMALLQUERYENUMERATEDFLAGS, + "EnumAnyGetEnumeratedFlagValue", // OSF16_ENUMANYGETENUMERATEDFLAGVALUE, + "StoreFlagsEnumeratedValue", // OSF16_STOREFLAGSENUMERATEDVALUE, + "RetrieveFlagsEnumeratedValue", // OSF16_RETRIEVEFLAGSENUMERATEDVALUE, +}; +static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE16, OSF16__MAX, const char *> g_aszSimpleFlags16FeatureTestNames; + + +bool TestSimpleFlags16(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OSF16__MAX, g_aszSimpleFlags16FeatureTestNames.GetStoragePointer(), g_afnSimpleFlags16FeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +typedef CSimpleFlagsTemplate<uint8ou> CSimpleFlags8; + +const uint8ou g_uiTestValue8 = (uint8ou)0xA5; +const uint8ou g_uiTestMask8 = (uint8ou)0xC6; +const uint8ou g_uiTestBit8 = (uint8ou)OU_INT8_MIN; +const uint8ou g_uiTestAnotherBit8 = (uint8ou)((uint8ou)OU_INT8_MIN >> 1); + + +bool TestSimpleFlags8_Constructors() +{ + bool bResult = false; + + do + { + if (sizeof(CSimpleFlags8::value_type) != sizeof(uint8ou) || sizeof(CSimpleFlags8) != sizeof(uint8ou)) + { + break; + } + + CSimpleFlags8 sfEmptyFlags; + + if (sfEmptyFlags.QueryFlagsAllValues()) + { + break; + } + + CSimpleFlags8 sfFullFlags(OU_UINT8_MAX); + + if (sfFullFlags.QueryFlagsAllValues() != OU_UINT8_MAX) + { + break; + } + + CSimpleFlags8 sfCopyOfFullFlags(sfFullFlags); + + if (sfCopyOfFullFlags.QueryFlagsAllValues() != OU_UINT8_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_AssignFlagsAllValues() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags; + + sfTestFlags.AssignFlagsAllValues(OU_UINT8_MAX); + + if (sfTestFlags.QueryFlagsAllValues() != OU_UINT8_MAX) + { + break; + } + + sfTestFlags.AssignFlagsAllValues(0); + + if (sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_QueryFlagsAllValues() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue8) + { + break; + } + + // Double check to be sure ;-) + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue8) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_SetFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + + sfTestFlags.SetFlagsMaskValue(g_uiTestMask8, true); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(g_uiTestValue8 | g_uiTestMask8)) + { + break; + } + + sfTestFlags.SetFlagsMaskValue(g_uiTestValue8, false); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(~g_uiTestValue8 & g_uiTestMask8)) + { + break; + } + + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_SignalFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + + sfTestFlags.SignalFlagsMaskValue(g_uiTestMask8); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(g_uiTestValue8 | g_uiTestMask8)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_DropFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + + sfTestFlags.DropFlagsMaskValue(g_uiTestMask8); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(g_uiTestValue8 & ~g_uiTestMask8)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_ToggleSingleFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + + bool bPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit8); + + if (bPreviousValue != ((g_uiTestValue8 & g_uiTestBit8) != 0) || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(g_uiTestValue8 ^ g_uiTestBit8)) + { + break; + } + + bool bAnotherPreviousValue = sfTestFlags.ToggleSingleFlagValue(g_uiTestBit8); + + if (bAnotherPreviousValue == bPreviousValue || sfTestFlags.QueryFlagsAllValues() != g_uiTestValue8) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_ModifySingleFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + + bool bFirstModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit8, true); + + if (bFirstModification != ((g_uiTestValue8 & g_uiTestBit8) != g_uiTestBit8) || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(g_uiTestValue8 | g_uiTestBit8)) + { + break; + } + + bool bAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit8, bFirstModification); + + if (bAnotherModification == bFirstModification || sfTestFlags.QueryFlagsAllValues() != (bFirstModification ? (uint8ou)(g_uiTestValue8 | g_uiTestBit8) : (uint8ou)(g_uiTestValue8 & ~g_uiTestBit8))) + { + break; + } + + bool bYetAnotherModification = sfTestFlags.ModifySingleFlagValue(g_uiTestBit8, bAnotherModification); + + if (bYetAnotherModification != bAnotherModification || sfTestFlags.QueryFlagsAllValues() != (bAnotherModification ? (uint8ou)(g_uiTestValue8 | g_uiTestBit8) : (uint8ou)(g_uiTestValue8 & ~g_uiTestBit8))) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_AssignFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + + uint8ou uiPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask8, g_uiTestMask8); + + const uint8ou uiNewFlags = (g_uiTestValue8 & ~g_uiTestMask8) | g_uiTestMask8; + + if (uiPreviousFlags != g_uiTestValue8 || sfTestFlags.QueryFlagsAllValues() != uiNewFlags) + { + break; + } + + uint8ou uiAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestValue8, 0); + + const uint8ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue8; + + if (uiAnotherPreviousFlags != uiNewFlags || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + uint8ou uiYetAnotherPreviousFlags = sfTestFlags.AssignFlagsByMask(g_uiTestMask8, g_uiTestMask8 & g_uiTestValue8); + OU_ASSERT((g_uiTestMask8 & g_uiTestValue8) != 0); // Test degeneration + + const uint8ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask8) | (g_uiTestMask8 & g_uiTestValue8); + OU_ASSERT(uiYetAnotherNewFlags != OU_UINT8_MAX); // Test degeneration + + if (uiYetAnotherPreviousFlags != uiAnotherNewFlags || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_AlterFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + + bool bWasModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask8, g_uiTestMask8); + + const uint8ou uiNewFlags = (g_uiTestValue8 & ~g_uiTestMask8) | g_uiTestMask8; + + if (bWasModification != ((g_uiTestValue8 & g_uiTestMask8) != g_uiTestMask8) || sfTestFlags.QueryFlagsAllValues() != uiNewFlags) + { + break; + } + + bool bWasAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestValue8, 0); + + const uint8ou uiAnotherNewFlags = uiNewFlags & ~g_uiTestValue8; + + if (bWasAnotherModification != ((uiNewFlags & g_uiTestValue8) != 0) || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + bool bWasAnotherModificationRepeated = sfTestFlags.AlterFlagsByMask(g_uiTestValue8, 0); + + if (bWasAnotherModificationRepeated || sfTestFlags.QueryFlagsAllValues() != uiAnotherNewFlags) + { + break; + } + + bool bWasYetAnotherModification = sfTestFlags.AlterFlagsByMask(g_uiTestMask8, g_uiTestMask8 & g_uiTestValue8); + OU_ASSERT((g_uiTestMask8 & g_uiTestValue8) != 0); // Test degeneration + + const uint8ou uiYetAnotherNewFlags = (uiAnotherNewFlags & ~g_uiTestMask8) | (g_uiTestMask8 & g_uiTestValue8); + OU_ASSERT(uiYetAnotherNewFlags != OU_UINT8_MAX); // Test degeneration + + if (bWasYetAnotherModification != ((uiAnotherNewFlags & g_uiTestMask8) != (g_uiTestMask8 & g_uiTestValue8)) || sfTestFlags.QueryFlagsAllValues() != uiYetAnotherNewFlags) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_GetFlagsMaskValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + + if (sfTestFlags.GetFlagsMaskValue(g_uiTestMask8) != ((g_uiTestValue8 & g_uiTestMask8) != 0)) + { + break; + } + + if (sfTestFlags.GetFlagsMaskValue((uint8ou)(~g_uiTestValue8))) + { + break; + } + + if (!sfTestFlags.GetFlagsMaskValue(OU_UINT8_MAX)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_QueryFlagsByMask() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + + if (sfTestFlags.QueryFlagsByMask(g_uiTestMask8) != (uint8ou)(g_uiTestValue8 & g_uiTestMask8)) + { + break; + } + + if (sfTestFlags.QueryFlagsByMask(0)) + { + break; + } + + if (sfTestFlags.QueryFlagsByMask(OU_UINT8_MAX) != g_uiTestValue8) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_OnlySignalSingleFlagOutOfMask() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(g_uiTestValue8); + OU_ASSERT(g_uiTestValue8 != 0); // Test degeneration + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT8_MAX, g_uiTestBit8)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestValue8) + { + break; + } + + sfTestFlags.AssignFlagsAllValues(0); + + if (!sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit8, g_uiTestBit8)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit8) + { + break; + } + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(g_uiTestBit8, g_uiTestBit8)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit8) + { + break; + } + + if (sfTestFlags.OnlySignalSingleFlagOutOfMask(OU_UINT8_MAX, g_uiTestAnotherBit8)) + { + break; + } + + if (sfTestFlags.QueryFlagsAllValues() != g_uiTestBit8) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumSetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags; + + sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT8_BITS, true); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS, true); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, 0, OU_UINT8_BITS, false); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)OU_INT8_MIN) + { + break; + } + + sfTestFlags.EnumSetEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS, false); + + if (sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumSignalEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags; + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT8_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, 0, OU_UINT8_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1)) + { + break; + } + + sfTestFlags.EnumSignalEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumDropEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(OU_UINT8_MAX); + + sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT8_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (OU_UINT8_MAX ^ 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)~(OU_INT8_MIN + 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, 0, OU_UINT8_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)~(OU_INT8_MIN + 1)) + { + break; + } + + sfTestFlags.EnumDropEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)~(OU_INT8_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumToggleEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags; + + bool bToggleFirstResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT8_BITS); + + if (bToggleFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bToggleSecondResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS); + + if (bToggleSecondResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1)) + { + break; + } + + bool bToggleThirdResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, 0, OU_UINT8_BITS); + + if (!bToggleThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)OU_INT8_MIN) + { + break; + } + + bool bToggleFourthResult = sfTestFlags.EnumToggleEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS); + + if (!bToggleFourthResult || sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumModifyEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags; + + bool bModifyFirstResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT8_BITS, true); + + if (!bModifyFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bModifySecondResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS, true); + + if (!bModifySecondResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1)) + { + break; + } + + bool bModifyThirdResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT8_BITS, true); + + if (bModifyThirdResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1)) + { + break; + } + + bool bModifyFourthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS, true); + + if (bModifyFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 1)) + { + break; + } + + bool bModifyFifthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, 0, OU_UINT8_BITS, false); + + if (!bModifyFifthResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)OU_INT8_MIN) + { + break; + } + + bool bModifySixthResult = sfTestFlags.EnumModifyEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS, false); + + if (!bModifySixthResult || sfTestFlags.QueryFlagsAllValues() != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumSignalFirstEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags; + + bool bFirstResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT8_BITS); + + if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, 0, OU_UINT8_BITS); + + if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(2, 0, OU_UINT8_BITS - 1); + + if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3) + { + break; + } + + bool bFourthResult = sfTestFlags.EnumSignalFirstEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS); + + if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 3)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumSignalLastEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags; + + bool bFirstResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1); + + if (!bFirstResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 0, 1); + + if (bSecondResult || sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, 1, 2); + + if (!bThirdResult || sfTestFlags.QueryFlagsAllValues() != 3) + { + break; + } + + bool bFourthResult = sfTestFlags.EnumSignalLastEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS); + + if (bFourthResult || sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_INT8_MIN + 3)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumGetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags((uint8ou)(OU_INT8_MIN + 1)); + + if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, 0, OU_UINT8_BITS)) + { + break; + } + + if (sfTestFlags.EnumGetEnumeratedFlagValue(2, 0, OU_UINT8_BITS - 1)) + { + break; + } + + if (sfTestFlags.EnumGetEnumeratedFlagValue(1, 1, OU_UINT8_BITS - 1)) + { + break; + } + + if (!sfTestFlags.EnumGetEnumeratedFlagValue(1, OU_UINT8_BITS - 1, OU_UINT8_BITS)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumFindFirstEnumeratedFlag() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags((uint8ou)(OU_INT8_MIN + 1)); + + unsigned int uiFirstResult = sfTestFlags.EnumFindFirstEnumeratedFlag(1, OU_UINT8_BITS); + if (uiFirstResult != 0) + { + break; + } + + unsigned int uiSecondResult = sfTestFlags.EnumFindFirstEnumeratedFlag(2, OU_UINT8_BITS - 1); + if (uiSecondResult != OU_UINT8_BITS - 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumAllSignalEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags; + + sfTestFlags.EnumAllSignalEnumeratedFlags(1, 1); + + if (sfTestFlags.QueryFlagsAllValues() != 1) + { + break; + } + + sfTestFlags.EnumAllSignalEnumeratedFlags(4, OU_UINT8_BITS - 2); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_UINT8_MAX ^ 2)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumAllDropEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags(OU_UINT8_MAX); + + sfTestFlags.EnumAllDropEnumeratedFlags(1, 1); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(OU_UINT8_MAX ^ 1)) + { + break; + } + + sfTestFlags.EnumAllDropEnumeratedFlags(4, OU_UINT8_BITS - 2); + + if (sfTestFlags.QueryFlagsAllValues() != 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumAllQueryEnumeratedFlags() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags((uint8ou)(OU_INT8_MIN + 1)); + + uint8ou uiFirstResult = sfTestFlags.EnumAllQueryEnumeratedFlags(1, OU_UINT8_BITS); + if (uiFirstResult != (uint8ou)(OU_INT8_MIN + 1)) + { + break; + } + + uint8ou uiSecondResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT8_BITS - 1); + if (uiSecondResult != (uint8ou)(OU_INT8_MIN)) + { + break; + } + + uint8ou uiThirdResult = sfTestFlags.EnumAllQueryEnumeratedFlags(2, OU_UINT8_BITS - 2); + if (uiThirdResult != 0) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_EnumAnyGetEnumeratedFlagValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags((uint8ou)(OU_INT8_MIN + 1)); + + bool bFirstResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(1, OU_UINT8_BITS); + if (!bFirstResult) + { + break; + } + + bool bSecondResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT8_BITS - 1); + if (!bSecondResult) + { + break; + } + + bool bThirdResult = sfTestFlags.EnumAnyGetEnumeratedFlagValue(2, OU_UINT8_BITS - 2); + if (bThirdResult) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_StoreFlagsEnumeratedValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags; + + sfTestFlags.StoreFlagsEnumeratedValue(0x03, 1, 2); + + if (sfTestFlags.QueryFlagsAllValues() != (uint8ou)(2 << 1)) + { + break; + } + + sfTestFlags.StoreFlagsEnumeratedValue(0x03, OU_UINT8_BITS - 2, 3); + + if (sfTestFlags.QueryFlagsAllValues() != ((uint8ou)(2 << 1) | (uint8ou)(OU_INT8_MIN | (OU_INT8_MIN >> 1)))) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestSimpleFlags8_RetrieveFlagsEnumeratedValue() +{ + bool bResult = false; + + do + { + CSimpleFlags8 sfTestFlags((uint8ou)(OU_INT8_MIN + 1)); + + unsigned int uiFirstResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, 1); + if (uiFirstResult != 0) + { + break; + } + + unsigned int uiSecondResult = sfTestFlags.RetrieveFlagsEnumeratedValue(0x3, OU_UINT8_BITS - 2); + if (uiSecondResult != 2) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUSIMPLEFLAGSFEATURE8 +{ + OSF8__MIN, + + OSF8_CONSTRUCTORS = OSF8__MIN, + OSF8_ASSIGNFLAGSALLVALUES, + OSF8_QUERYFLAGSALLVALUES, + OSF8_SETFLAGSMASKVALUE, + OSF8_SIGNALFLAGSMASKVALUE, + OSF8_DROPFLAGSMASKVALUE, + OSF8_TOGGLESINGLEFLAGVALUE, + OSF8_MODIFYSINGLEFLAGVALUE, + OSF8_ASSIGNFLAGSBYMASK, + OSF8_ALTERFLAGSBYMASK, + OSF8_GETFLAGSMASKVALUE, + OSF8_QUERYFLAGSBYMASK, + OSF8_ONLYSIGNALSINGLEFLAGOUTOFMASK, + OSF8_ENUMSETENUMERATEDFLAGVALUE, + OSF8_ENUMSIGNALENUMERATEDFLAGVALUE, + OSF8_ENUMDROPENUMERATEDFLAGVALUE, + OSF8_ENUMTOGGLEENUMERATEDFLAGVALUE, + OSF8_ENUMMODIFYENUMERATEDFLAGVALUE, + OSF8_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + OSF8_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + OSF8_ENUMGETENUMERATEDFLAGVALUE, + OSF8_ENUMFINDFIRSTENUMERATEDFLAG, + OSF8_ENUMALLSIGNALENUMERATEDFLAGS, + OSF8_ENUMALLDROPENUMERATEDFLAGS, + OSF8_ENUMALLQUERYENUMERATEDFLAGS, + OSF8_ENUMANYGETENUMERATEDFLAGVALUE, + OSF8_STOREFLAGSENUMERATEDVALUE, + OSF8_RETRIEVEFLAGSENUMERATEDVALUE, + + OSF8__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE8, OSF8__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestSimpleFlags8_Constructors, // OSF8_CONSTRUCTORS + &TestSimpleFlags8_AssignFlagsAllValues, // OSF8_ASSIGNFLAGSALLVALUES, + &TestSimpleFlags8_QueryFlagsAllValues, // OSF8_QUERYFLAGSALLVALUES, + &TestSimpleFlags8_SetFlagsMaskValue, // OSF8_SETFLAGSMASKVALUE, + &TestSimpleFlags8_SignalFlagsMaskValue, // OSF8_SIGNALFLAGSMASKVALUE, + &TestSimpleFlags8_DropFlagsMaskValue, // OSF8_DROPFLAGSMASKVALUE, + &TestSimpleFlags8_ToggleSingleFlagValue, // OSF8_TOGGLESINGLEFLAGVALUE, + &TestSimpleFlags8_ModifySingleFlagValue, // OSF8_MODIFYSINGLEFLAGVALUE, + &TestSimpleFlags8_AssignFlagsByMask, // OSF8_ASSIGNFLAGSBYMASK, + &TestSimpleFlags8_AlterFlagsByMask, // OSF8_ALTERFLAGSBYMASK, + &TestSimpleFlags8_GetFlagsMaskValue, // OSF8_GETFLAGSMASKVALUE, + &TestSimpleFlags8_QueryFlagsByMask, // OSF8_QUERYFLAGSBYMASK, + &TestSimpleFlags8_OnlySignalSingleFlagOutOfMask, // OSF8_ONLYSIGNALSINGLEFLAGOUTOFMASK, + &TestSimpleFlags8_EnumSetEnumeratedFlagValue, // OSF8_ENUMSETENUMERATEDFLAGVALUE, + &TestSimpleFlags8_EnumSignalEnumeratedFlagValue, // OSF8_ENUMSIGNALENUMERATEDFLAGVALUE, + &TestSimpleFlags8_EnumDropEnumeratedFlagValue, // OSF8_ENUMDROPENUMERATEDFLAGVALUE, + &TestSimpleFlags8_EnumToggleEnumeratedFlagValue, // OSF8_ENUMTOGGLEENUMERATEDFLAGVALUE, + &TestSimpleFlags8_EnumModifyEnumeratedFlagValue, // OSF8_ENUMMODIFYENUMERATEDFLAGVALUE, + &TestSimpleFlags8_EnumSignalFirstEnumeratedFlagValue, // OSF8_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + &TestSimpleFlags8_EnumSignalLastEnumeratedFlagValue, // OSF8_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + &TestSimpleFlags8_EnumGetEnumeratedFlagValue, // OSF8_ENUMGETENUMERATEDFLAGVALUE, + &TestSimpleFlags8_EnumFindFirstEnumeratedFlag, // OSF8_ENUMFINDFIRSTENUMERATEDFLAG, + &TestSimpleFlags8_EnumAllSignalEnumeratedFlags, // OSF8_ENUMALLSIGNALENUMERATEDFLAGS, + &TestSimpleFlags8_EnumAllDropEnumeratedFlags, // OSF8_ENUMALLDROPENUMERATEDFLAGS, + &TestSimpleFlags8_EnumAllQueryEnumeratedFlags, // OSF8_ENUMALLQUERYENUMERATEDFLAGS, + &TestSimpleFlags8_EnumAnyGetEnumeratedFlagValue, // OSF8_ENUMANYGETENUMERATEDFLAGVALUE, + &TestSimpleFlags8_StoreFlagsEnumeratedValue, // OSF8_STOREFLAGSENUMERATEDVALUE, + &TestSimpleFlags8_RetrieveFlagsEnumeratedValue, // OSF8_RETRIEVEFLAGSENUMERATEDVALUE, +}; +static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE8, OSF8__MAX, CFeatureTestProcedure> g_afnSimpleFlags8FeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE8, OSF8__MAX, const char *>::m_aetElementArray[] = +{ + "Constructors", // OSF8_CONSTRUCTORS + "AssignFlagsAllValues", // OSF8_ASSIGNFLAGSALLVALUES, + "QueryFlagsAllValues", // OSF8_QUERYFLAGSALLVALUES, + "SetFlagsMaskValue", // OSF8_SETFLAGSMASKVALUE, + "SignalFlagsMaskValue", // OSF8_SIGNALFLAGSMASKVALUE, + "DropFlagsMaskValue", // OSF8_DROPFLAGSMASKVALUE, + "ToggleSingleFlagValue", // OSF8_TOGGLESINGLEFLAGVALUE, + "ModifySingleFlagValue", // OSF8_MODIFYSINGLEFLAGVALUE, + "AssignFlagsByMask", // OSF8_ASSIGNFLAGSBYMASK, + "AlterFlagsByMask", // OSF8_ALTERFLAGSBYMASK, + "GetFlagsMaskValue", // OSF8_GETFLAGSMASKVALUE, + "QueryFlagsByMask", // OSF8_QUERYFLAGSBYMASK, + "OnlySignalSingleFlagOutOfMask", // OSF8_ONLYSIGNALSINGLEFLAGOUTOFMASK, + "EnumSetEnumeratedFlagValue", // OSF8_ENUMSETENUMERATEDFLAGVALUE, + "EnumSignalEnumeratedFlagValue", // OSF8_ENUMSIGNALENUMERATEDFLAGVALUE, + "EnumDropEnumeratedFlagValue", // OSF8_ENUMDROPENUMERATEDFLAGVALUE, + "EnumToggleEnumeratedFlagValue", // OSF8_ENUMTOGGLEENUMERATEDFLAGVALUE, + "EnumModifyEnumeratedFlagValue", // OSF8_ENUMMODIFYENUMERATEDFLAGVALUE, + "EnumSignalFirstEnumeratedFlagValue", // OSF8_ENUMSIGNALFIRSTENUMERATEDFLAGVALUE, + "EnumSignalLastEnumeratedFlagValue", // OSF8_ENUMSIGNALLASTENUMERATEDFLAGVALUE, + "EnumGetEnumeratedFlagValue", // OSF8_ENUMGETENUMERATEDFLAGVALUE, + "EnumFindFirstEnumeratedFlag", // OSF8_ENUMFINDFIRSTENUMERATEDFLAG, + "EnumAllSignalEnumeratedFlags", // OSF8_ENUMALLSIGNALENUMERATEDFLAGS, + "EnumAllDropEnumeratedFlags", // OSF8_ENUMALLDROPENUMERATEDFLAGS, + "EnumAllQueryEnumeratedFlags", // OSF8_ENUMALLQUERYENUMERATEDFLAGS, + "EnumAnyGetEnumeratedFlagValue", // OSF8_ENUMANYGETENUMERATEDFLAGVALUE, + "StoreFlagsEnumeratedValue", // OSF8_STOREFLAGSENUMERATEDVALUE, + "RetrieveFlagsEnumeratedValue", // OSF8_RETRIEVEFLAGSENUMERATEDVALUE, +}; +static const CEnumUnsortedElementArray<EOUSIMPLEFLAGSFEATURE8, OSF8__MAX, const char *> g_aszSimpleFlags8FeatureTestNames; + + +bool TestSimpleFlags8(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OSF8__MAX, g_aszSimpleFlags8FeatureTestNames.GetStoragePointer(), g_afnSimpleFlags8FeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +bool TestFlagsDefines_EnumFlagsMask() +{ + bool bResult = false; + + do + { + int64ou iMask; + + iMask = OU_FLAGS_ENUMFLAGS_MASK(uint8ou, 1, 1); + if (iMask - 1 != 0) + { + break; + } + + iMask = OU_FLAGS_ENUMFLAGS_MASK(uint8ou, 1, OU_UINT8_BITS); + if (iMask ^ OU_UINT8_MAX) + { + break; + } + + iMask = OU_FLAGS_ENUMFLAGS_MASK(uint16ou, 1, 1); + if (iMask - 1 != 0) + { + break; + } + + iMask = OU_FLAGS_ENUMFLAGS_MASK(uint16ou, 1, OU_UINT16_BITS); + if (iMask ^ OU_UINT16_MAX) + { + break; + } + + iMask = OU_FLAGS_ENUMFLAGS_MASK(uint32ou, 1, 1); + if (iMask - 1 != 0) + { + break; + } + + iMask = OU_FLAGS_ENUMFLAGS_MASK(uint32ou, 1, OU_UINT32_BITS); + if (iMask ^ OU_UINT32_MAX) + { + break; + } + + iMask = OU_FLAGS_ENUMFLAGS_MASK(uint64ou, 1, 1); + if (iMask - 1 != 0) + { + break; + } + + iMask = OU_FLAGS_ENUMFLAGS_MASK(uint64ou, 1, OU_UINT64_BITS); + if (iMask ^ OU_UINT64_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestFlagsDefines_EnumFlagsStartValid() +{ + bool bResult = false; + + do + { + if (!OU_FLAGS_ENUMFLAGS_START_VALID(uint8ou, 1, OU_UINT8_BITS)) + { + break; + } +/* + if (OU_FLAGS_ENUMFLAGS_START_VALID(uint8ou, 1, OU_UINT8_BITS + 1)) + { + break; + } +*/ + if (!OU_FLAGS_ENUMFLAGS_START_VALID(uint16ou, 1, OU_UINT16_BITS)) + { + break; + } +/* + if (OU_FLAGS_ENUMFLAGS_START_VALID(uint16ou, 1, OU_UINT16_BITS + 1)) + { + break; + } +*/ + if (!OU_FLAGS_ENUMFLAGS_START_VALID(uint32ou, 1, OU_UINT32_BITS)) + { + break; + } +/* + if (OU_FLAGS_ENUMFLAGS_START_VALID(uint32ou, 1, OU_UINT32_BITS + 1)) + { + break; + } +*/ + if (!OU_FLAGS_ENUMFLAGS_START_VALID(uint64ou, 1, OU_UINT64_BITS)) + { + break; + } +/* + if (OU_FLAGS_ENUMFLAGS_START_VALID(uint64ou, 1, OU_UINT64_BITS + 1)) + { + break; + } +*/ + bResult = true; + } + while (false); + + return bResult; +} + +bool TestFlagsDefines_StoreEnumValueInMask() +{ + bool bResult = false; + + do + { + if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 0, 1) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 1, 1)) + { + break; + } + + if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 0, OU_UINT8_MAX) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, OU_UINT8_MAX, OU_UINT8_MAX)) + { + break; + } + + if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 1, 2) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 2, 1)) + { + break; + } + + if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 0, 0) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint8ou, 1, 0)) + { + break; + } + + if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 0, 1) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 1, 1)) + { + break; + } + + if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 0, OU_UINT16_MAX) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, OU_UINT16_MAX, OU_UINT16_MAX)) + { + break; + } + + if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 1, 2) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 2, 1)) + { + break; + } + + if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 0, 0) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint16ou, 1, 0)) + { + break; + } + + if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 0, 1) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 1, 1)) + { + break; + } + + if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 0, OU_UINT32_MAX) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, OU_UINT32_MAX, OU_UINT32_MAX)) + { + break; + } + + if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 1, 2) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 2, 1)) + { + break; + } + + if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 0, 0) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint32ou, 1, 0)) + { + break; + } + + if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 0, 1) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 1, 1)) + { + break; + } + + if (!OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 0, OU_UINT64_MAX) || !OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, OU_UINT64_MAX, OU_UINT64_MAX)) + { + break; + } + + if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 1, 2) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 2, 1)) + { + break; + } + + if (OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 0, 0) || OU_FLAGS_STOREENUM_VALUE_IN_MASK(uint64ou, 1, 0)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestFlagsDefines_FlagIsSingle() +{ + bool bResult = false; + + do + { + if (!OU_FLAGS_FLAG_IS_SINGLE(uint8ou, 1) || !OU_FLAGS_FLAG_IS_SINGLE(uint8ou, OU_INT8_MIN)) + { + break; + } + + if (OU_FLAGS_FLAG_IS_SINGLE(uint8ou, 0) || OU_FLAGS_FLAG_IS_SINGLE(uint8ou, 3) || OU_FLAGS_FLAG_IS_SINGLE(uint8ou, OU_INT8_MIN + 1)) + { + break; + } + + if (!OU_FLAGS_FLAG_IS_SINGLE(uint16ou, 1) || !OU_FLAGS_FLAG_IS_SINGLE(uint16ou, OU_INT16_MIN)) + { + break; + } + + if (OU_FLAGS_FLAG_IS_SINGLE(uint16ou, 0) || OU_FLAGS_FLAG_IS_SINGLE(uint16ou, 3) || OU_FLAGS_FLAG_IS_SINGLE(uint16ou, OU_INT16_MIN + 1)) + { + break; + } + + if (!OU_FLAGS_FLAG_IS_SINGLE(uint32ou, 1) || !OU_FLAGS_FLAG_IS_SINGLE(uint32ou, OU_INT32_MIN)) + { + break; + } + + if (OU_FLAGS_FLAG_IS_SINGLE(uint32ou, 0) || OU_FLAGS_FLAG_IS_SINGLE(uint32ou, 3) || OU_FLAGS_FLAG_IS_SINGLE(uint32ou, OU_INT32_MIN + 1)) + { + break; + } + + if (!OU_FLAGS_FLAG_IS_SINGLE(uint64ou, 1) || !OU_FLAGS_FLAG_IS_SINGLE(uint64ou, OU_INT64_MIN)) + { + break; + } + + if (OU_FLAGS_FLAG_IS_SINGLE(uint64ou, 0) || OU_FLAGS_FLAG_IS_SINGLE(uint64ou, 3) || OU_FLAGS_FLAG_IS_SINGLE(uint64ou, OU_INT64_MIN + 1)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUFLAGSDEFINESFEATURE +{ + OFF__MIN, + + OFF_ENUMFLAGS_MASK = OFF__MIN, + OFF_ENUMFLAGS_START_VALID, + OFF_STOREENUM_VALUE_IN_MASK, + OFF_FLAG_IS_SINGLE, + + OFF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUFLAGSDEFINESFEATURE, OFF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestFlagsDefines_EnumFlagsMask, // OFF_ENUMFLAGS_MASK, + &TestFlagsDefines_EnumFlagsStartValid, // OFF_ENUMFLAGS_START_VALID, + &TestFlagsDefines_StoreEnumValueInMask, // OFF_STOREENUM_VALUE_IN_MASK, + &TestFlagsDefines_FlagIsSingle, // OFF_FLAG_IS_SINGLE, +}; +static const CEnumUnsortedElementArray<EOUFLAGSDEFINESFEATURE, OFF__MAX, CFeatureTestProcedure> g_afnFlagsDefineFeatureTestProcedures; + +template<>const char *const CEnumUnsortedElementArray<EOUFLAGSDEFINESFEATURE, OFF__MAX, const char *>::m_aetElementArray[] = +{ + "ENUMFLAGS_MASK", // OFF_ENUMFLAGS_MASK = OFF__MIN, + "ENUMFLAGS_START_VALID", // OFF_ENUMFLAGS_START_VALID, + "STOREENUM_VALUE_IN_MASK", // OFF_STOREENUM_VALUE_IN_MASK, + "FLAG_IS_SINGLE", // OFF_FLAG_IS_SINGLE, +}; +static const CEnumUnsortedElementArray<EOUFLAGSDEFINESFEATURE, OFF__MAX, const char *> g_aszFlagsDefineFeatureTestNames; + + +bool TestFlagsDefines(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OFF__MAX, g_aszFlagsDefineFeatureTestNames.GetStoragePointer(), g_afnFlagsDefineFeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +enum EENUMARRAYTESTENUM +{ + ATE__MIN, + + ATE_FIRSTELEMENT = ATE__MIN, + ATE_SECONDELEMENT, + ATE_THIRDELEMENT, + + ATE__MAX, +}; + +template<> +const int CEnumUnsortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, int>::m_aetElementArray[] = +{ + 1, // ATE_FIRSTELEMENT, + 3, // ATE_SECONDELEMENT, + 2, // ATE_THIRDELEMENT, +}; +static const CEnumUnsortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, int> g_ai_IntUnsortedArray; + +template<> +const int CEnumSortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, int>::m_aetElementArray[] = +{ + 1, // ATE_FIRSTELEMENT, + 2, // ATE_SECONDELEMENT, + 3, // ATE_THIRDELEMENT, +}; +static const CEnumSortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, int> g_ai_IntSortedArray; + +struct ConstCharPtrEq +{ + bool operator ()(const char *szLeftValue, const char *szRightValue) const + { + return strcmp(szLeftValue, szRightValue) == 0; + } +}; + +struct ConstCharPtrLess +{ + bool operator ()(const char *szLeftValue, const char *szRightValue) const + { + return strcmp(szLeftValue, szRightValue) < 0; + } +}; + +template<> +const char *const CEnumUnsortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, const char *, 0, ConstCharPtrEq>::m_aetElementArray[] = +{ + "first", + "third", + "second", +}; +static const CEnumUnsortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, const char *, 0, ConstCharPtrEq> g_aszStringUnsortedArray; + +template<> +const char *const CEnumSortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, const char *, 0, ConstCharPtrLess>::m_aetElementArray[] = +{ + "first", + "second", + "third", +}; +static const CEnumSortedElementArray<EENUMARRAYTESTENUM, ATE__MAX, const char *, 0, ConstCharPtrLess> g_aszStringSortedArray; + + +bool TestEnumArrays_UnsortedArray() +{ + EENUMARRAYTESTENUM teEnumCurrent = ATE__MIN; + + for (; teEnumCurrent != ATE__MAX; ++teEnumCurrent) + { + int iCurrentValue = g_ai_IntUnsortedArray.Encode(teEnumCurrent); + EENUMARRAYTESTENUM teIntDecodeCheck = g_ai_IntUnsortedArray.Decode(iCurrentValue); + + if (!g_ai_IntUnsortedArray.IsValidDecode(teIntDecodeCheck) || teIntDecodeCheck != teEnumCurrent) + { + break; + } + + if (g_ai_IntUnsortedArray.GetStoragePointer()[teEnumCurrent] != iCurrentValue) + { + break; + } + + const char *szCurrentString = g_aszStringUnsortedArray.Encode(teEnumCurrent); + EENUMARRAYTESTENUM teStringDecodeCheck = g_aszStringUnsortedArray.Decode(szCurrentString); + + if (!g_aszStringUnsortedArray.IsValidDecode(teStringDecodeCheck) || teStringDecodeCheck != teEnumCurrent) + { + break; + } + + if (strcmp(g_aszStringUnsortedArray.GetStoragePointer()[teEnumCurrent], szCurrentString) != 0) + { + break; + } + + EENUMARRAYTESTENUM teInvalidDecodeCheck = g_aszStringUnsortedArray.Decode(szCurrentString + 1); + if (teInvalidDecodeCheck != ATE__MAX || g_aszStringUnsortedArray.IsValidDecode(teInvalidDecodeCheck)) + { + break; + } + } + + bool bResult = teEnumCurrent == ATE__MAX; + return bResult; +} + +bool TestEnumArrays_SortedArray() +{ + EENUMARRAYTESTENUM teEnumCurrent = ATE__MIN; + + for (; teEnumCurrent != ATE__MAX; ++teEnumCurrent) + { + int iCurrentValue = g_ai_IntSortedArray.Encode(teEnumCurrent); + EENUMARRAYTESTENUM teIntDecodeCheck = g_ai_IntSortedArray.Decode(iCurrentValue); + + if (!g_ai_IntSortedArray.IsValidDecode(teIntDecodeCheck) || teIntDecodeCheck != teEnumCurrent) + { + break; + } + + if (g_ai_IntSortedArray.GetStoragePointer()[teEnumCurrent] != iCurrentValue) + { + break; + } + + const char *szCurrentString = g_aszStringSortedArray.Encode(teEnumCurrent); + EENUMARRAYTESTENUM teStringDecodeCheck = g_aszStringSortedArray.Decode(szCurrentString); + + if (!g_aszStringSortedArray.IsValidDecode(teStringDecodeCheck) || teStringDecodeCheck != teEnumCurrent) + { + break; + } + + if (strcmp(g_aszStringSortedArray.GetStoragePointer()[teEnumCurrent], szCurrentString) != 0) + { + break; + } + + EENUMARRAYTESTENUM teInvalidDecodeCheck = g_aszStringSortedArray.Decode(szCurrentString + 1); + if (teInvalidDecodeCheck != ATE__MAX || g_aszStringSortedArray.IsValidDecode(teInvalidDecodeCheck)) + { + break; + } + } + + bool bResult = teEnumCurrent == ATE__MAX; + return bResult; +} + + +enum EOUENUMARRAYSFEATURE +{ + ORF__MIN, + + ORF_UNSORTEDARRAY = ORF__MIN, + ORF_SORTEDARRAY, + + ORF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUENUMARRAYSFEATURE, ORF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestEnumArrays_UnsortedArray, // ORF_UNSORTEDARRAY, + &TestEnumArrays_SortedArray, // ORF_SORTEDARRAY, +}; +static const CEnumUnsortedElementArray<EOUENUMARRAYSFEATURE, ORF__MAX, CFeatureTestProcedure> g_afnEnumArrayFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUENUMARRAYSFEATURE, ORF__MAX, const char *>::m_aetElementArray[] = +{ + "Unsorted Array", // ORF_UNSORTEDARRAY, + "Sorted Array", // ORF_SORTEDARRAY, +}; +static const CEnumUnsortedElementArray<EOUENUMARRAYSFEATURE, ORF__MAX, const char *> g_aszEnumArrayFeatureTestNames; + + +bool TestEnumArrays(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, ORF__MAX, g_aszEnumArrayFeatureTestNames.GetStoragePointer(), g_afnEnumArrayFeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +enum ETESTTEMPLATES8 +{ + TT8_ONE, + TT8_TWO, +}; + +enum ETESTTEMPLATES16 +{ + TT16_ONE = 1000, + TT16_TWO, +}; + +enum ETESTTEMPLATES32 +{ + TT32_ONE = 100000, + TT32_TWO, +}; + + +bool TestTemplates_PrefixIncrement() +{ + bool bResult = false; + + do + { + ETESTTEMPLATES8 t8Test = TT8_ONE; + ETESTTEMPLATES16 t16Test = TT16_ONE; + ETESTTEMPLATES32 t32Test = TT32_ONE; + + if (++t8Test != TT8_TWO || t8Test != TT8_TWO) + { + break; + } + + ++t8Test = TT8_ONE; + if (t8Test != TT8_ONE) + { + break; + } + + if (++t16Test != TT16_TWO || t16Test != TT16_TWO) + { + break; + } + + ++t16Test = TT16_ONE; + if (t16Test != TT16_ONE) + { + break; + } + + if (++t32Test != TT32_TWO || t32Test != TT32_TWO) + { + break; + } + + ++t32Test = TT32_ONE; + if (t32Test != TT32_ONE) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTemplates_PostfixIncrement() +{ + bool bResult = false; + + do + { + ETESTTEMPLATES8 t8Test = TT8_ONE; + ETESTTEMPLATES16 t16Test = TT16_ONE; + ETESTTEMPLATES32 t32Test = TT32_ONE; + + if (t8Test++ != TT8_ONE || t8Test != TT8_TWO) + { + break; + } + + if (t16Test++ != TT16_ONE || t16Test != TT16_TWO) + { + break; + } + + if (t32Test++ != TT32_ONE || t32Test != TT32_TWO) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTemplates_PrefixDecrement() +{ + bool bResult = false; + + do + { + ETESTTEMPLATES8 t8Test = TT8_TWO; + ETESTTEMPLATES16 t16Test = TT16_TWO; + ETESTTEMPLATES32 t32Test = TT32_TWO; + + if (--t8Test != TT8_ONE || t8Test != TT8_ONE) + { + break; + } + + --t8Test = TT8_TWO; + if (t8Test != TT8_TWO) + { + break; + } + + if (--t16Test != TT16_ONE || t16Test != TT16_ONE) + { + break; + } + + --t16Test = TT16_TWO; + if (t16Test != TT16_TWO) + { + break; + } + + if (--t32Test != TT32_ONE || t32Test != TT32_ONE) + { + break; + } + + --t32Test = TT32_TWO; + if (t32Test != TT32_TWO) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTemplates_PostfixDecrement() +{ + bool bResult = false; + + do + { + ETESTTEMPLATES8 t8Test = TT8_TWO; + ETESTTEMPLATES16 t16Test = TT16_TWO; + ETESTTEMPLATES32 t32Test = TT32_TWO; + + if (t8Test-- != TT8_TWO || t8Test != TT8_ONE) + { + break; + } + + if (t16Test-- != TT16_TWO || t16Test != TT16_ONE) + { + break; + } + + if (t32Test-- != TT32_TWO || t32Test != TT32_ONE) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTemplates_IsEmptySz() +{ + bool bResult = false; + + do + { + const char *szData = "a"; + const char *szEmpty = ""; + const char *szNull = NULL; + + if (IsEmptySz(szData) || !IsEmptySz(szEmpty) || !IsEmptySz(szNull)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUTEMPLATESFEATURE +{ + OTF__MIN, + + OTF_PREFIXINCREMENT = OTF__MIN, + OTF_POSTFIXINCREMENT, + OTF_PREFIXDECREMENT, + OTF_POSTFIXDECREMENT, + OTF_ISEMPTYSZ, + + OTF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUTEMPLATESFEATURE, OTF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestTemplates_PrefixIncrement, // OTF_PREFIXINCREMENT, + &TestTemplates_PostfixIncrement, // OTF_POSTFIXINCREMENT, + &TestTemplates_PrefixDecrement, // OTF_PREFIXDECREMENT, + &TestTemplates_PostfixDecrement, // OTF_POSTFIXDECREMENT, + &TestTemplates_IsEmptySz, // OTF_ISEMPTYSZ, +}; +static const CEnumUnsortedElementArray<EOUTEMPLATESFEATURE, OTF__MAX, CFeatureTestProcedure> g_afnTemplateFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUTEMPLATESFEATURE, OTF__MAX, const char *>::m_aetElementArray[] = +{ + "Prefix Increment", // OTF_PREFIXINCREMENT, + "Postfix Increment", // OTF_POSTFIXINCREMENT, + "Prefix Decrement", // OTF_PREFIXDECREMENT, + "Postfix Decrement", // OTF_POSTFIXDECREMENT, + "IsEmptySz", // OTF_ISEMPTYSZ, +}; +static const CEnumUnsortedElementArray<EOUTEMPLATESFEATURE, OTF__MAX, const char *> g_aszTemplateFeatureTestNames; + + +bool TestTemplates(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OTF__MAX, g_aszTemplateFeatureTestNames.GetStoragePointer(), g_afnTemplateFeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +typedef CTypeSimpleWrapper<int> CTestWrapper; + +bool TestTypeWrappers_Constructors() +{ + CTestWrapper twEmptyWrapper; + CTestWrapper twZeroWrapper(0); + CTestWrapper twCopyWrapper(twZeroWrapper); + + return true; +} + +bool TestTypeWrappers_Comparison() +{ + bool bResult = false; + + do + { + CTestWrapper twOneWrapper(1); + CTestWrapper twTwoWrapper(2); + + if (!(twTwoWrapper == twTwoWrapper) || twOneWrapper == twTwoWrapper) + { + break; + } + + if (twTwoWrapper != twTwoWrapper || !(twOneWrapper != twTwoWrapper)) + { + break; + } + + if (!(twOneWrapper < twTwoWrapper) || twTwoWrapper < twTwoWrapper || twTwoWrapper < twOneWrapper) + { + break; + } + + if (twOneWrapper > twTwoWrapper || twTwoWrapper > twTwoWrapper || !(twTwoWrapper > twOneWrapper)) + { + break; + } + + if (!(twOneWrapper <= twTwoWrapper) || !(twTwoWrapper <= twTwoWrapper) || twTwoWrapper <= twOneWrapper) + { + break; + } + + if (twOneWrapper >= twTwoWrapper || !(twTwoWrapper >= twTwoWrapper) || !(twTwoWrapper >= twOneWrapper)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTypeWrappers_BoolCasts() +{ + bool bResult = false; + + do + { + CTestWrapper twZeroWrapper(0); + CTestWrapper twOneWrapper(1); +/* -- cast to bool is commented in definition + if (twZeroWrapper || !(false || twOneWrapper)) + { + break; + } +*/ + if (!(!twZeroWrapper) || !twOneWrapper) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTypeWrappers_Assignment() +{ + bool bResult = false; + + do + { + CTestWrapper twZeroWrapper(0); + CTestWrapper twOneWrapper(1); + + CTestWrapper twTestWrapper; + + CTestWrapper &twFirstAssignmentReference = (twTestWrapper = (CTestWrapper::value_type)1); + + if (twTestWrapper != twOneWrapper || &twFirstAssignmentReference != &twTestWrapper) + { + break; + } + + CTestWrapper &twSecondAssignmentReference = (twTestWrapper = twZeroWrapper); + + if (twTestWrapper != twZeroWrapper || &twSecondAssignmentReference != &twTestWrapper) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTypeWrappers_DataCast() +{ + bool bResult = false; + + do + { + const CTestWrapper twZeroWrapper(0); + CTestWrapper twOneWrapper(1); + + const CTestWrapper::value_type &wtZeroValue = (const CTestWrapper::value_type &)twZeroWrapper; + CTestWrapper::value_type &wtOneValue = (CTestWrapper::value_type &)twOneWrapper; + + if (wtZeroValue != 0 || wtOneValue != 1) + { + break; + } + + wtOneValue = 0; + + if (twOneWrapper != twZeroWrapper) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestTypeWrappers_DataComparison() +{ + bool bResult = false; + + do + { + const CTestWrapper twZeroWrapper(0); + const CTestWrapper twOneWrapper(1); + + const CTestWrapper::value_type &wtZeroValue = twZeroWrapper; + const CTestWrapper::value_type &wtOneValue = twOneWrapper; + + if (!(twZeroWrapper == wtZeroValue) || (twZeroWrapper == wtOneValue)) + { + break; + } + + if (!(wtZeroValue == twZeroWrapper) || (wtOneValue == twZeroWrapper)) + { + break; + } + + if ((twZeroWrapper != wtZeroValue) || !(twZeroWrapper != wtOneValue)) + { + break; + } + + if ((wtZeroValue != twZeroWrapper) || !(wtOneValue != twZeroWrapper)) + { + break; + } + + if ((twZeroWrapper < wtZeroValue) || !(twZeroWrapper < wtOneValue) || (twOneWrapper < wtZeroValue)) + { + break; + } + + if ((wtZeroValue < twZeroWrapper) || (wtOneValue < twZeroWrapper) || !(wtZeroValue < twOneWrapper)) + { + break; + } + + if ((twZeroWrapper > wtZeroValue) || (twZeroWrapper > wtOneValue) || !(twOneWrapper > wtZeroValue)) + { + break; + } + + if ((wtZeroValue > twZeroWrapper) || !(wtOneValue > twZeroWrapper) || (wtZeroValue > twOneWrapper)) + { + break; + } + + if (!(twZeroWrapper <= wtZeroValue) || !(twZeroWrapper <= wtOneValue) || (twOneWrapper <= wtZeroValue)) + { + break; + } + + if (!(wtZeroValue <= twZeroWrapper) || (wtOneValue <= twZeroWrapper) || !(wtZeroValue <= twOneWrapper)) + { + break; + } + + if (!(twZeroWrapper >= wtZeroValue) || (twZeroWrapper >= wtOneValue) || !(twOneWrapper >= wtZeroValue)) + { + break; + } + + if (!(wtZeroValue >= twZeroWrapper) || !(wtOneValue >= twZeroWrapper) || (wtZeroValue >= twOneWrapper)) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUTYPEWRAPPERFEATURE +{ + OWF__MIN, + + OWF_CONSTRUCTORS = OWF__MIN, + OWF_COMPARISON, + OWF_BOOLCASTS, + OWF_ASSIGNMENT, + OWF_DATACAST, + OWF_DATACOMPARISON, + + OWF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUTYPEWRAPPERFEATURE, OWF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestTypeWrappers_Constructors, // OWF_CONSTRUCTORS, + &TestTypeWrappers_Comparison, // OWF_COMPARISON, + &TestTypeWrappers_BoolCasts, // OWF_BOOLCASTS, + &TestTypeWrappers_Assignment, // OWF_ASSIGNMENT, + &TestTypeWrappers_DataCast, // OWF_DATACAST, + &TestTypeWrappers_DataComparison, // OWF_DATACOMPARISON, +}; +static const CEnumUnsortedElementArray<EOUTYPEWRAPPERFEATURE, OWF__MAX, CFeatureTestProcedure> g_afnTypeWrapperFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUTYPEWRAPPERFEATURE, OWF__MAX, const char *>::m_aetElementArray[] = +{ + "Constructors", // OWF_CONSTRUCTORS, + "Comparison Operators", // OWF_COMPARISON, + "Boolean Casts", // OWF_BOOLCASTS, + "Assignment Operators", // OWF_ASSIGNMENT, + "Data Cast", // OWF_DATACAST, + "Data Comparisons", // OWF_DATACOMPARISON, +}; +static const CEnumUnsortedElementArray<EOUTYPEWRAPPERFEATURE, OWF__MAX, const char *> g_aszTypeWrapperFeatureTestNames; + + +bool TestTypeWrapper(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OWF__MAX, g_aszTypeWrapperFeatureTestNames.GetStoragePointer(), g_afnTypeWrapperFeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +struct CTestCustomizations_Asserts_FailureInfo +{ + EASSERTIONFAILURESEVERITY m_fsFailureSeverity; + const char *m_szAssertionExpression; + const char *m_szAssertionFileName; + unsigned int m_uiAssertionSourceLine; +}; + +static const CTestCustomizations_Asserts_FailureInfo g_fiAssertInvalidInfo = { AFS__MAX, NULL, NULL, 0 }; +static CTestCustomizations_Asserts_FailureInfo g_fiAssertLastInfo; + +void _OU_CONVENTION_CALLBACK TestCustomizations_Asserts_AssertionFailure(EASSERTIONFAILURESEVERITY fsFailureSeverity, + const char *szAssertionExpression, const char *szAssertionFileName, unsigned int uiAssertionSourceLine) +{ + g_fiAssertLastInfo.m_fsFailureSeverity = fsFailureSeverity; + g_fiAssertLastInfo.m_szAssertionExpression = szAssertionExpression; + g_fiAssertLastInfo.m_szAssertionFileName = szAssertionFileName; + g_fiAssertLastInfo.m_uiAssertionSourceLine = uiAssertionSourceLine; +} + + +bool TestCustomizations_Asserts() +{ + bool bResult = false; + + CAssertionFailedProcedure fnAssertOldHandler = CAssertionCheckCustomization::GetAssertFailureCustomHandler(); + CAssertionCheckCustomization::CustomizeAssertionChecks(&TestCustomizations_Asserts_AssertionFailure); + + do + { +#if !defined(NDEBUG) + // Only callback invocation is checked here. + // Availability of functionality depending on preprocessor defines + // is verified in OST_ASSERT subsystem. + + OU_ASSERT(false); // const unsigned int uiAssertToVerifyLines = 14; -- see further in code + + if (g_fiAssertLastInfo.m_fsFailureSeverity != AFS_ASSERT + || g_fiAssertLastInfo.m_szAssertionExpression == NULL + || g_fiAssertLastInfo.m_szAssertionFileName == NULL + || strcmp(g_fiAssertLastInfo.m_szAssertionFileName, __FILE__) != 0 + || g_fiAssertLastInfo.m_uiAssertionSourceLine == 0) + { + break; + } + + CTestCustomizations_Asserts_FailureInfo fiAssertFailureInfoSave = g_fiAssertLastInfo; + g_fiAssertLastInfo = g_fiAssertInvalidInfo; + + OU_VERIFY(false); const unsigned int uiAssertToVerifyLines = 14; + + if (g_fiAssertLastInfo.m_fsFailureSeverity != AFS_ASSERT + || g_fiAssertLastInfo.m_szAssertionExpression == NULL + || strcmp(g_fiAssertLastInfo.m_szAssertionExpression, fiAssertFailureInfoSave.m_szAssertionExpression) != 0 + || g_fiAssertLastInfo.m_szAssertionFileName == NULL + || strcmp(g_fiAssertLastInfo.m_szAssertionFileName, __FILE__) != 0 + || g_fiAssertLastInfo.m_uiAssertionSourceLine != fiAssertFailureInfoSave.m_uiAssertionSourceLine + uiAssertToVerifyLines) + { + break; + } + + g_fiAssertLastInfo = g_fiAssertInvalidInfo; + + +#endif // #if !defined(NDEBUG) + +/* -- can't verify OU_CHECK() as it crashes the application on failure + OU_CHECK(false); + + if (g_fiAssertLastInfo.m_fsFailureSeverity != AFS_CHECK + || g_fiAssertLastInfo.m_szAssertionExpression == NULL + || g_fiAssertLastInfo.m_szAssertionFileName == NULL + || strcmp(g_fiAssertLastInfo.m_szAssertionFileName, __FILE__) != 0 + || g_fiAssertLastInfo.m_uiAssertionSourceLine == 0) + { + break; + } +*/ + bResult = true; + } + while (false); + + CAssertionCheckCustomization::CustomizeAssertionChecks(fnAssertOldHandler); + + return bResult; +} + +void *const g_pv_MallocResult = (void *)(size_t)0x12345678; +bool g_bMallocInvocation = false, g_bReallocInvocation = false; +bool g_bFreeInvocation = false, g_bFreeSuccess = false; + +void *_OU_CONVENTION_CALLBACK TestCustomizations_MemMgr_Alloc(size_t nBlockSize) +{ + g_bMallocInvocation = true; + return (void *)((ptrdiff_t)g_pv_MallocResult + nBlockSize); +} + +void *_OU_CONVENTION_CALLBACK TestCustomizations_MemMgr_Realloc(void *pv_OldBlock, size_t nBlockNewSize) +{ + g_bReallocInvocation = true; + return (void *)((ptrdiff_t)pv_OldBlock - nBlockNewSize); +} + +void _OU_CONVENTION_CALLBACK TestCustomizations_MemMgr_Free(void *pv_OldBlock) +{ + g_bFreeInvocation = true; + g_bFreeSuccess = pv_OldBlock == g_pv_MallocResult; +} + + +bool TestCustomizations_MemMgr() +{ + bool bResult = false; + + CMemoryAllocationProcedure fnAllocationOldProcedure = CMemoryManagerCustomization::GetMemoryAllocationCustomProcedure(); + CMemoryReallocationProcedure fnReallocationOldProcedure = CMemoryManagerCustomization::GetMemoryReallocationCustomProcedure(); + CMemoryDeallocationProcedure fnDeallocationOldProcedure = CMemoryManagerCustomization::GetMemoryDeallocationCustomProcedure(); + CMemoryManagerCustomization::CustomizeMemoryManager(&TestCustomizations_MemMgr_Alloc, &TestCustomizations_MemMgr_Realloc, &TestCustomizations_MemMgr_Free); + + do + { + const size_t nBlockSize = 0x1000; + + void *pv_BlockAllocated = AllocateMemoryBlock(nBlockSize); + + if (!g_bMallocInvocation + || pv_BlockAllocated != (void *)((size_t)g_pv_MallocResult + nBlockSize)) + { + break; + } + + void *pv_BlockReallocated = ReallocateMemoryBlock(pv_BlockAllocated, 2 * nBlockSize); + + if (!g_bReallocInvocation + || pv_BlockReallocated != (void *)((size_t)g_pv_MallocResult - nBlockSize)) + { + break; + } + + FreeMemoryBlock(g_pv_MallocResult); + + if (!g_bFreeInvocation || !g_bFreeSuccess) + { + break; + } + + bResult = true; + } + while (false); + + CMemoryManagerCustomization::CustomizeMemoryManager(fnAllocationOldProcedure, fnReallocationOldProcedure, fnDeallocationOldProcedure); + + return bResult; +} + + +enum EOUCUSTOMIZATIONFEATURE +{ + OCF__MIN, + + OCF_ASSERTS = OCF__MIN, + OCF_MEMMGR, + + OCF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUCUSTOMIZATIONFEATURE, OCF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestCustomizations_Asserts, // OCF_ASSERTS, + &TestCustomizations_MemMgr, // OCF_MEMMGR, +}; +static const CEnumUnsortedElementArray<EOUCUSTOMIZATIONFEATURE, OCF__MAX, CFeatureTestProcedure> g_afnCustomizationFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUCUSTOMIZATIONFEATURE, OCF__MAX, const char *>::m_aetElementArray[] = +{ + "Asserts", // OCF_ASSERTS, + "Memory Manager", // OCF_MEMMGR, +}; +static const CEnumUnsortedElementArray<EOUCUSTOMIZATIONFEATURE, OCF__MAX, const char *> g_aszCustomizationFeatureTestNames; + + +bool TestCustomization(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OCF__MAX, g_aszCustomizationFeatureTestNames.GetStoragePointer(), g_afnCustomizationFeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +static const size_t g_nTestMallocBlockInitialSize = 1001; +static const size_t g_nTestMallocBlockNextSize = 65501; +static const uint8ou g_uiTestMallocToken = 0xAA; +static void *g_pv_MemoryBlock = NULL; + +bool TestMallocs_Allocate() +{ + bool bResult = false; + + do + { + g_pv_MemoryBlock = AllocateMemoryBlock(g_nTestMallocBlockInitialSize); + + if (g_pv_MemoryBlock == NULL || OU_ALIGNED_SIZE((size_t)g_pv_MemoryBlock, _OU_MEMORY_REQUIRED_ALIGNMENT) != (size_t)g_pv_MemoryBlock) + { + break; + } + + *((uint8ou *)g_pv_MemoryBlock + g_nTestMallocBlockInitialSize - 1) = g_uiTestMallocToken; + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestMallocs_Reallocate() +{ + OU_ASSERT(g_nTestMallocBlockNextSize > g_nTestMallocBlockInitialSize); + + bool bResult = false; + + do + { + void *pv_OldMemoryBlock = g_pv_MemoryBlock; + g_pv_MemoryBlock = ReallocateMemoryBlock(pv_OldMemoryBlock, g_nTestMallocBlockNextSize); + + if (g_pv_MemoryBlock == NULL || OU_ALIGNED_SIZE((size_t)g_pv_MemoryBlock, _OU_MEMORY_REQUIRED_ALIGNMENT) != (size_t)g_pv_MemoryBlock) + { + break; + } + + if (*((uint8ou *)g_pv_MemoryBlock + g_nTestMallocBlockInitialSize - 1) != g_uiTestMallocToken) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +bool TestMallocs_Deallocate() +{ + FreeMemoryBlock(g_pv_MemoryBlock); + + FreeMemoryBlock(NULL); // Free must survive NULL-pointer + + return true; +} + + +enum EOUMALLOCFEATURE +{ + OLF__MIN, + + OLF_ALLOCATE = OLF__MIN, + OLF_REALLOCATE, + OLF_DEALLOCATE, + + OLF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUMALLOCFEATURE, OLF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestMallocs_Allocate, // OLF_ALLOCATE, + &TestMallocs_Reallocate, // OLF_REALLOCATE, + &TestMallocs_Deallocate, // OLF_DEALLOCATE, +}; +static const CEnumUnsortedElementArray<EOUMALLOCFEATURE, OLF__MAX, CFeatureTestProcedure> g_afnMallocFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUMALLOCFEATURE, OLF__MAX, const char *>::m_aetElementArray[] = +{ + "AllocateMemoryBlock", // OLF_ALLOCATE, + "ReallocateMemoryBlock", // OLF_REALLOCATE, + "FreeMemoryBlock", // OLF_DEALLOCATE, +}; +static const CEnumUnsortedElementArray<EOUMALLOCFEATURE, OLF__MAX, const char *> g_aszMallocFeatureTestNames; + + +bool TestMalloc(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OLF__MAX, g_aszMallocFeatureTestNames.GetStoragePointer(), g_afnMallocFeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +bool TestAsserts_FalseFunction(bool &bVarInvocation) +{ + bool bResult = true; + bVarInvocation = !bVarInvocation; + + bool *pv_Pointer = &bResult; + if (pv_Pointer) + { + bResult = false; + } + + return bResult; +} + +bool TestAsserts_TrueFunction(bool &bVarInvocation) +{ + bool bResult = false; + bVarInvocation = !bVarInvocation; + + bool *pv_Pointer = &bResult; + if (pv_Pointer) + { + bResult = true; + } + + return bResult; +} + +bool TestAsserts_Assert() +{ + bool bNDebugInvocation = false, bOrdinaryInvocation = false; + +#if defined(NDEBUG) + + OU_ASSERT(TestAsserts_FalseFunction(bNDebugInvocation)); + + bOrdinaryInvocation = true; + +#endif // #if defined(NDEBUG) + + OU_ASSERT(TestAsserts_TrueFunction(bOrdinaryInvocation)); + + return !bNDebugInvocation && bOrdinaryInvocation; +} + +bool TestAsserts_Verify() +{ + bool bNDebugInvocation = false, bOrdinaryInvocation = false; + +#if defined(NDEBUG) + + OU_VERIFY(TestAsserts_FalseFunction(bNDebugInvocation)); + + +#else // #if !defined(NDEBUG) + + bNDebugInvocation = true; + + +#endif // #if !defined(NDEBUG) + + OU_VERIFY(TestAsserts_TrueFunction(bOrdinaryInvocation)); + + return bNDebugInvocation && bOrdinaryInvocation; +} + +bool TestAsserts_Check() +{ + bool bOrdinaryInvocation = false; + + OU_CHECK(TestAsserts_TrueFunction(bOrdinaryInvocation)); + + return bOrdinaryInvocation; +} + + +enum EOUASSERTFEATURE +{ + OEF__MIN, + + OEF_ASSERT = OEF__MIN, + OEF_VERIFY, + OEF_CHECK, + + OEF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUASSERTFEATURE, OEF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestAsserts_Assert, // OEF_ASSERT, + &TestAsserts_Verify, // OEF_VERIFY, + &TestAsserts_Check, // OEF_CHECK, + +}; +static const CEnumUnsortedElementArray<EOUASSERTFEATURE, OEF__MAX, CFeatureTestProcedure> g_afnAssertFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUASSERTFEATURE, OEF__MAX, const char *>::m_aetElementArray[] = +{ + "OU_ASSERT", // OEF_ASSERT, + "OU_VERIFY", // OEF_VERIFY, + "OU_CHECK", // OEF_CHECK, +}; +static const CEnumUnsortedElementArray<EOUASSERTFEATURE, OEF__MAX, const char *> g_aszAssertFeatureTestNames; + + +bool TestAssert(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OEF__MAX, g_aszAssertFeatureTestNames.GetStoragePointer(), g_afnAssertFeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +struct CTestIntTypes_int8 +{ + int8ou m_iPad; + int8ou m_iValue; +}; + +bool TestIntTypes_Int8() +{ + bool bResult = false; + + do + { + if (sizeof(int8ou) != 1 || offsetof(CTestIntTypes_int8, m_iValue) != 1) + { + break; + } + + if (OU_INT8_BITS != sizeof(int8ou) * OU_BITS_IN_BYTE ) + { + break; + } + + if ((int8ou)OU_INT8_MIN == 0 || (int8ou)(OU_INT8_MIN << 1) != 0) + { + break; + } + + if (~OU_INT8_MIN != OU_INT8_MAX || ~OU_INT8_MAX != OU_INT8_MIN) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +struct CTestIntTypes_uint8 +{ + int8ou m_iPad; + uint8ou m_iValue; +}; + +bool TestIntTypes_UInt8() +{ + bool bResult = false; + + do + { + if (sizeof(uint8ou) != 1 || offsetof(CTestIntTypes_uint8, m_iValue) != 1) + { + break; + } + + if (OU_UINT8_BITS != sizeof(uint8ou) * OU_BITS_IN_BYTE) + { + break; + } + + if (OU_UINT8_MIN != 0) + { + break; + } + + if (!(OU_UINT8_MAX & (uint8ou)1) || (OU_UINT8_MAX >> 1) != (uint8ou)OU_INT8_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +struct CTestIntTypes_int16 +{ + int8ou m_iPad; + int16ou m_iValue; +}; + +bool TestIntTypes_Int16() +{ + bool bResult = false; + + do + { + if (sizeof(int16ou) != 2 || offsetof(CTestIntTypes_int16, m_iValue) != 2) + { + break; + } + + if (OU_INT16_BITS != sizeof(int16ou) * OU_BITS_IN_BYTE ) + { + break; + } + + if ((int16ou)OU_INT16_MIN == 0 || (int16ou)(OU_INT16_MIN << 1) != 0) + { + break; + } + + if (~OU_INT16_MIN != OU_INT16_MAX || ~OU_INT16_MAX != OU_INT16_MIN) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +struct CTestIntTypes_uint16 +{ + int8ou m_iPad; + uint16ou m_iValue; +}; + +bool TestIntTypes_UInt16() +{ + bool bResult = false; + + do + { + if (sizeof(uint16ou) != 2 || offsetof(CTestIntTypes_uint16, m_iValue) != 2) + { + break; + } + + if (OU_UINT16_BITS != sizeof(uint16ou) * OU_BITS_IN_BYTE) + { + break; + } + + if (OU_UINT16_MIN != 0) + { + break; + } + + if (!(OU_UINT16_MAX & (uint16ou)1) || (OU_UINT16_MAX >> 1) != (uint16ou)OU_INT16_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +struct CTestIntTypes_int32 +{ + int8ou m_iPad; + int32ou m_iValue; +}; + +bool TestIntTypes_Int32() +{ + bool bResult = false; + + do + { + if (sizeof(int32ou) != 4 || offsetof(CTestIntTypes_int32, m_iValue) != 4) + { + break; + } + + if (OU_INT32_BITS != sizeof(int32ou) * OU_BITS_IN_BYTE ) + { + break; + } + + if ((int32ou)OU_INT32_MIN == 0 || (int32ou)(OU_INT32_MIN << 1) != 0) + { + break; + } + + if (~OU_INT32_MIN != OU_INT32_MAX || ~OU_INT32_MAX != OU_INT32_MIN) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +struct CTestIntTypes_uint32 +{ + int8ou m_iPad; + uint32ou m_iValue; +}; + +bool TestIntTypes_UInt32() +{ + bool bResult = false; + + do + { + if (sizeof(uint32ou) != 4 || offsetof(CTestIntTypes_uint32, m_iValue) != 4) + { + break; + } + + if (OU_UINT32_BITS != sizeof(uint32ou) * OU_BITS_IN_BYTE) + { + break; + } + + if (OU_UINT32_MIN != 0) + { + break; + } + + if (!(OU_UINT32_MAX & (uint32ou)1) || (OU_UINT32_MAX >> 1) != (uint32ou)OU_INT32_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +struct CTestIntTypes_int64 +{ + int8ou m_iPad; + int64ou m_iValue; +}; + +bool TestIntTypes_Int64() +{ + bool bResult = false; + + do + { + if (sizeof(int64ou) != 8) + { + break; + } + +#if _OU_TARGET_ARCH == _OU_TARGET_ARCH_X86 && _OU_TARGET_OS != _OU_TARGET_OS_MAC + + if (offsetof(CTestIntTypes_int64, m_iValue) != 8) + { + break; + } + + +#endif + + if (OU_INT64_BITS != sizeof(int64ou) * OU_BITS_IN_BYTE ) + { + break; + } + + if ((int64ou)OU_INT64_MIN == 0 || (int64ou)(OU_INT64_MIN << 1) != 0) + { + break; + } + + if (~OU_INT64_MIN != OU_INT64_MAX || ~OU_INT64_MAX != OU_INT64_MIN) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + +struct CTestIntTypes_uint64 +{ + int8ou m_iPad; + uint64ou m_iValue; +}; + +bool TestIntTypes_UInt64() +{ + bool bResult = false; + + do + { + if (sizeof(uint64ou) != 8) + { + break; + } + +#if _OU_TARGET_ARCH == _OU_TARGET_ARCH_X86 && _OU_TARGET_OS != _OU_TARGET_OS_MAC + + if (offsetof(CTestIntTypes_uint64, m_iValue) != 8) + { + break; + } + + +#endif + + if (OU_UINT64_BITS != sizeof(uint64ou) * OU_BITS_IN_BYTE) + { + break; + } + + if (OU_UINT64_MIN != 0) + { + break; + } + + if (!(OU_UINT64_MAX & (uint64ou)1) || (OU_UINT64_MAX >> 1) != (uint64ou)OU_INT64_MAX) + { + break; + } + + bResult = true; + } + while (false); + + return bResult; +} + + +enum EOUINTTYPEFEATURE +{ + OIF__MIN, + + OIF_INT8 = OIF__MIN, + OIF_UINT8, + OIF_INT16, + OIF_UINT16, + OIF_INT32, + OIF_UINT32, + OIF_INT64, + OIF_UINT64, + + OIF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUINTTYPEFEATURE, OIF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestIntTypes_Int8, // OIF_INT8, + &TestIntTypes_UInt8, // OIF_UINT8, + &TestIntTypes_Int16, // OIF_INT16, + &TestIntTypes_UInt16, // OIF_UINT16, + &TestIntTypes_Int32, // OIF_INT32, + &TestIntTypes_UInt32, // OIF_UINT32, + &TestIntTypes_Int64, // OIF_INT64, + &TestIntTypes_UInt64, // OIF_UINT64, + +}; +static const CEnumUnsortedElementArray<EOUINTTYPEFEATURE, OIF__MAX, CFeatureTestProcedure> g_afnIntTypeFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUINTTYPEFEATURE, OIF__MAX, const char *>::m_aetElementArray[] = +{ + "int8ou", // OIF_INT8, + "uint8ou", // OIF_UINT8, + "int16ou", // OIF_INT16, + "uint16ou", // OIF_UINT16, + "int32ou", // OIF_INT32, + "uint32ou", // OIF_UINT32, + "int64ou", // OIF_INT64, + "uint64ou", // OIF_UINT64, +}; +static const CEnumUnsortedElementArray<EOUINTTYPEFEATURE, OIF__MAX, const char *> g_aszIntTypeFeatureTestNames; + + +bool TestIntTypes(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OIF__MAX, g_aszIntTypeFeatureTestNames.GetStoragePointer(), g_afnIntTypeFeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +struct CTestMacros_OffsetStruct +{ + int8ou m_i8a; + int16ou m_i16a; + int32ou m_i32a; + int64ou m_i64; + int32ou m_i32b; + int16ou m_i16b; + int8ou m_i8b; +}; + +bool TestMacros_OffsetOf() +{ + size_t sOffset_i8a = offsetof(CTestMacros_OffsetStruct, m_i8a); + size_t sOffset_i16a = offsetof(CTestMacros_OffsetStruct, m_i16a); + size_t sOffset_i32a = offsetof(CTestMacros_OffsetStruct, m_i32a); + size_t sOffset_i64 = offsetof(CTestMacros_OffsetStruct, m_i64); + size_t sOffset_i32b = offsetof(CTestMacros_OffsetStruct, m_i32b); + size_t sOffset_i16b = offsetof(CTestMacros_OffsetStruct, m_i16b); + size_t sOffset_i8b = offsetof(CTestMacros_OffsetStruct, m_i8b); + size_t sStructSize = sizeof(CTestMacros_OffsetStruct); + + return true + && sOffset_i8a == 0 + && sOffset_i16a == 2 + && sOffset_i32a == 4 + && sOffset_i64 == 8 + && sOffset_i32b == 16 + && sOffset_i16b == 20 + && sOffset_i8b == 22 + && sStructSize == 24; +} + +bool TestMacros_AlignedSize() +{ + return true + && OU_ALIGNED_SIZE(0, sizeof(int8ou)) == 0 + && OU_ALIGNED_SIZE(0, sizeof(int16ou)) == 0 + && OU_ALIGNED_SIZE(0, sizeof(int32ou)) == 0 + && OU_ALIGNED_SIZE(0, sizeof(int64ou)) == 0 + && OU_ALIGNED_SIZE(sizeof(int8ou), sizeof(int8ou)) == sizeof(int8ou) + && OU_ALIGNED_SIZE(sizeof(int8ou), sizeof(int16ou)) == sizeof(int16ou) + && OU_ALIGNED_SIZE(sizeof(int8ou), sizeof(int32ou)) == sizeof(int32ou) + && OU_ALIGNED_SIZE(sizeof(int8ou), sizeof(int64ou)) == sizeof(int64ou) + && OU_ALIGNED_SIZE(sizeof(int16ou), sizeof(int8ou)) == sizeof(int16ou) + && OU_ALIGNED_SIZE(sizeof(int16ou), sizeof(int16ou)) == sizeof(int16ou) + && OU_ALIGNED_SIZE(sizeof(int16ou), sizeof(int32ou)) == sizeof(int32ou) + && OU_ALIGNED_SIZE(sizeof(int16ou), sizeof(int64ou)) == sizeof(int64ou) + && OU_ALIGNED_SIZE(sizeof(int32ou), sizeof(int8ou)) == sizeof(int32ou) + && OU_ALIGNED_SIZE(sizeof(int32ou), sizeof(int16ou)) == sizeof(int32ou) + && OU_ALIGNED_SIZE(sizeof(int32ou), sizeof(int32ou)) == sizeof(int32ou) + && OU_ALIGNED_SIZE(sizeof(int32ou), sizeof(int64ou)) == sizeof(int64ou) + && OU_ALIGNED_SIZE(sizeof(int64ou), sizeof(int8ou)) == sizeof(int64ou) + && OU_ALIGNED_SIZE(sizeof(int64ou), sizeof(int16ou)) == sizeof(int64ou) + && OU_ALIGNED_SIZE(sizeof(int64ou), sizeof(int32ou)) == sizeof(int64ou) + && OU_ALIGNED_SIZE(sizeof(int64ou), sizeof(int64ou)) == sizeof(int64ou); +} + +bool TestMacros_ArraySize() +{ + static int m_ai_Array1[1]; + static int m_aai_Array11[1][1]; + static int m_ai_Array2[2]; + static int m_aai_Array21[2][1]; + static int m_aai_Array12[1][2]; + + return true + && OU_ARRAY_SIZE(m_ai_Array1) == 1 + && OU_ARRAY_SIZE(m_aai_Array11[0]) == 1 + && OU_ARRAY_SIZE(m_aai_Array11) == 1 + && OU_ARRAY_SIZE(m_ai_Array2) == 2 + && OU_ARRAY_SIZE(m_aai_Array21[0]) == 1 + && OU_ARRAY_SIZE(m_aai_Array21) == 2 + && OU_ARRAY_SIZE(m_aai_Array12[0]) == 2 + && OU_ARRAY_SIZE(m_aai_Array12) == 1; +} + +bool TestMacros_InIntRange() +{ + char iZero = 0; + char iOne = 1; + char iMinusOne = -1; + unsigned int uiTen = 10; + unsigned int uiNotZero = ~0U; + + return true + && !OU_IN_INT_RANGE(iZero, 0, 0) + && !OU_IN_INT_RANGE(iOne, 0, 0) + && !OU_IN_INT_RANGE(iMinusOne, 0, 0) + && !OU_IN_INT_RANGE(uiTen, 0, 0) + && !OU_IN_INT_RANGE(uiNotZero, 0, 0) + + && OU_IN_INT_RANGE(iZero, 0, 1) + && !OU_IN_INT_RANGE(iOne, 0, 1) + && !OU_IN_INT_RANGE(iMinusOne, 0, 1) + && !OU_IN_INT_RANGE(uiTen, 0, 1) + && !OU_IN_INT_RANGE(uiNotZero, 0, 1) + + && !OU_IN_INT_RANGE(iZero, 1, 2) + && OU_IN_INT_RANGE(iOne, 1, 2) + && !OU_IN_INT_RANGE(iMinusOne, 1, 2) + && !OU_IN_INT_RANGE(uiTen, 1, 2) + && !OU_IN_INT_RANGE(uiNotZero, 1, 2) + + && OU_IN_INT_RANGE(iZero, -1, 1) + && !OU_IN_INT_RANGE(iOne, -1, 1) + && OU_IN_INT_RANGE(iMinusOne, -1, 1) + && !OU_IN_INT_RANGE(uiTen, -1, 1) + && OU_IN_INT_RANGE(uiNotZero, -1, 1) + + && !OU_IN_INT_RANGE(iZero, 1, -1) + && OU_IN_INT_RANGE(iOne, 1, -1) + && !OU_IN_INT_RANGE(iMinusOne, 1, -1) + && OU_IN_INT_RANGE(uiTen, 1, -1) + && !OU_IN_INT_RANGE(uiNotZero, 1, -1); +} + +bool TestMacros_InI64Range() +{ + char iZero = 0; + char iOne = 1; + char iMinusOne = -1; + unsigned int uiTen = 10; + unsigned int uiNotZero = ~0U; + + return true + && !OU_IN_I64_RANGE(iZero, 0, 0) + && !OU_IN_I64_RANGE(iOne, 0, 0) + && !OU_IN_I64_RANGE(iMinusOne, 0, 0) + && !OU_IN_I64_RANGE(uiTen, 0, 0) + && !OU_IN_I64_RANGE(uiNotZero, 0, 0) + + && OU_IN_I64_RANGE(iZero, 0, 1) + && !OU_IN_I64_RANGE(iOne, 0, 1) + && !OU_IN_I64_RANGE(iMinusOne, 0, 1) + && !OU_IN_I64_RANGE(uiTen, 0, 1) + && !OU_IN_I64_RANGE(uiNotZero, 0, 1) + + && !OU_IN_I64_RANGE(iZero, 1, 2) + && OU_IN_I64_RANGE(iOne, 1, 2) + && !OU_IN_I64_RANGE(iMinusOne, 1, 2) + && !OU_IN_I64_RANGE(uiTen, 1, 2) + && !OU_IN_I64_RANGE(uiNotZero, 1, 2) + + && OU_IN_I64_RANGE(iZero, -1, 1) + && !OU_IN_I64_RANGE(iOne, -1, 1) + && OU_IN_I64_RANGE(iMinusOne, -1, 1) + && !OU_IN_I64_RANGE(uiTen, -1, 1) + && !OU_IN_I64_RANGE(uiNotZero, -1, 1) + + && !OU_IN_I64_RANGE(iZero, 1, -1) + && OU_IN_I64_RANGE(iOne, 1, -1) + && !OU_IN_I64_RANGE(iMinusOne, 1, -1) + && OU_IN_I64_RANGE(uiTen, 1, -1) + && OU_IN_I64_RANGE(uiNotZero, 1, -1); +} + +bool TestMacros_InSizetRange() +{ + char iZero = 0; + char iOne = 1; + char iMinusOne = -1; + unsigned int uiTen = 10; + unsigned int uiNotZero = ~0U; + + return true + && !OU_IN_SIZET_RANGE(iZero, 0, 0) + && !OU_IN_SIZET_RANGE(iOne, 0, 0) + && !OU_IN_SIZET_RANGE(iMinusOne, 0, 0) + && !OU_IN_SIZET_RANGE(uiTen, 0, 0) + && !OU_IN_SIZET_RANGE(uiNotZero, 0, 0) + + && OU_IN_SIZET_RANGE(iZero, 0, 1) + && !OU_IN_SIZET_RANGE(iOne, 0, 1) + && !OU_IN_SIZET_RANGE(iMinusOne, 0, 1) + && !OU_IN_SIZET_RANGE(uiTen, 0, 1) + && !OU_IN_SIZET_RANGE(uiNotZero, 0, 1) + + && !OU_IN_SIZET_RANGE(iZero, 1, 2) + && OU_IN_SIZET_RANGE(iOne, 1, 2) + && !OU_IN_SIZET_RANGE(iMinusOne, 1, 2) + && !OU_IN_SIZET_RANGE(uiTen, 1, 2) + && !OU_IN_SIZET_RANGE(uiNotZero, 1, 2) + + && OU_IN_SIZET_RANGE(iZero, -1, 1) + && !OU_IN_SIZET_RANGE(iOne, -1, 1) + && OU_IN_SIZET_RANGE(iMinusOne, -1, 1) + && !OU_IN_SIZET_RANGE(uiTen, -1, 1) + && OU_IN_SIZET_RANGE(uiNotZero, -1, 1) == (sizeof(size_t) == sizeof(unsigned int)) + + && !OU_IN_SIZET_RANGE(iZero, 1, -1) + && OU_IN_SIZET_RANGE(iOne, 1, -1) + && !OU_IN_SIZET_RANGE(iMinusOne, 1, -1) + && OU_IN_SIZET_RANGE(uiTen, 1, -1) + && OU_IN_SIZET_RANGE(uiNotZero, 1, -1) != (sizeof(size_t) == sizeof(unsigned int)); +} + + +enum EOUMACROFEATURE +{ + OMF__MIN, + + OMF_OFFSETOF = OMF__MIN, + OMF_ALIGNEDSIZE, + OMF_ARRAYSIZE, + OMF_ININTRANGE, + OMF_INI64RANGE, + OMF_INSIZETRANGE, + + OMF__MAX, +}; + +template<> +CFeatureTestProcedure const CEnumUnsortedElementArray<EOUMACROFEATURE, OMF__MAX, CFeatureTestProcedure>::m_aetElementArray[] = +{ + &TestMacros_OffsetOf, // OMF_OFFSETOF, + &TestMacros_AlignedSize, // OMF_ALIGNEDSIZE, + &TestMacros_ArraySize, // OMF_ARRAYSIZE, + &TestMacros_InIntRange, // OMF_ININTRANGE, + &TestMacros_InI64Range, // OMF_INI64RANGE, + &TestMacros_InSizetRange, // OMF_INSIZETRANGE, +}; +static const CEnumUnsortedElementArray<EOUMACROFEATURE, OMF__MAX, CFeatureTestProcedure> g_afnMacroFeatureTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUMACROFEATURE, OMF__MAX, const char *>::m_aetElementArray[] = +{ + "offsetof", // OMF_OFFSETOF, + "OU_ALIGNED_SIZE", // OMF_ALIGNEDSIZE, + "OU_ARRAY_SIZE", // OMF_ARRAYSIZE, + "OU_IN_INT_RANGE", // OMF_ININTRANGE, + "OU_IN_I64_RANGE", // OMF_INI64RANGE, + "OU_IN_SIZET_RANGE", // OMF_INSIZETRANGE, +}; +static const CEnumUnsortedElementArray<EOUMACROFEATURE, OMF__MAX, const char *> g_aszMacroFeatureTestNames; + + +bool TestMacros(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + return TestSubsystem(nOutSuccessCount, nOutTestCount, OMF__MAX, g_aszMacroFeatureTestNames.GetStoragePointer(), g_afnMacroFeatureTestProcedures.GetStoragePointer()); +} + + +////////////////////////////////////////////////////////////////////////// + +// Verifies that target order is not changed +template<> +int const CEnumSortedElementArray<int, _OU_TARGET_OS__MAX - 1, int, 100>::m_aetElementArray[] = +{ + _OU_TARGET_OS_GENUNIX, // _OU_TARGET_OS_GENUNIX + _OU_TARGET_OS_WINDOWS, // _OU_TARGET_OS_WINDOWS + _OU_TARGET_OS_QNX, // _OU_TARGET_OS_QNX + _OU_TARGET_OS_MAC, // _OU_TARGET_OS_MAC + _OU_TARGET_OS_AIX, // _OU_TARGET_OS_AIX + _OU_TARGET_OS_SUNOS, // _OU_TARGET_OS_SUNOS + _OU_TARGET_OS_IOS, // _OU_TARGET_OS_IOS +}; +static const CEnumSortedElementArray<int, _OU_TARGET_OS__MAX - 1, int, 100> g_ai_TargetOrderCheck; + +template<> +const char *const CEnumUnsortedElementArray<int, _OU_TARGET_OS__MAX - 1, const char *, 100>::m_aetElementArray[] = +{ + "GENERIC UNIX", // _OU_TARGET_OS_GENUNIX + "WINDOWS", // _OU_TARGET_OS_WINDOWS + "QNX", // _OU_TARGET_OS_QNX + "MAC", // _OU_TARGET_OS_MAC + "AIX", // _OU_TARGET_OS_AIX + "SunOS", // _OU_TARGET_OS_SUNOS + "iOS", // _OU_TARGET_OS_IOS +}; +static const CEnumUnsortedElementArray<int, _OU_TARGET_OS__MAX - 1, const char *, 100> g_aszOSNames; + +// Verifies that bits order is not changed +template<> +int const CEnumSortedElementArray<int, _OU_TARGET_BITS__MAX - 1, int, 101>::m_aetElementArray[] = +{ + _OU_TARGET_BITS_32, // _OU_TARGET_BITS_32 + _OU_TARGET_BITS_64, // _OU_TARGET_BITS_64 +}; +static const CEnumSortedElementArray<int, _OU_TARGET_BITS__MAX - 1, int, 101> g_ai_BitsOrderCheck; + +template<> +const char *const CEnumUnsortedElementArray<int, _OU_TARGET_BITS__MAX - 1, const char *, 101>::m_aetElementArray[] = +{ + "32", // _OU_TARGET_BITS_32 + "64", // _OU_TARGET_BITS_64 +}; +static const CEnumUnsortedElementArray<int, _OU_TARGET_BITS__MAX - 1, const char *, 101> g_aszBitsNames; + +// Verifies that architectures order is not changed +template<> +int const CEnumSortedElementArray<int, _OU_TARGET_ARCH__MAX - 1, int, 102>::m_aetElementArray[] = +{ + _OU_TARGET_ARCH_OTHER, // _OU_TARGET_ARCH_OTHER + _OU_TARGET_ARCH_X86, // _OU_TARGET_ARCH_X86 + _OU_TARGET_ARCH_IA64, // _OU_TARGET_ARCH_IA64 + _OU_TARGET_ARCH_X64, // _OU_TARGET_ARCH_X64 + _OU_TARGET_ARCH_POWERPC, // _OU_TARGET_ARCH_POWERPC + _OU_TARGET_ARCH_SPARC, // _OU_TARGET_ARCH_SPARC + _OU_TARGET_ARCH_ARM, // _OU_TARGET_ARCH_ARM +}; +static const CEnumSortedElementArray<int, _OU_TARGET_ARCH__MAX - 1, int, 102> g_ai_ArchitecturesOrderCheck; + +template<> +const char *const CEnumUnsortedElementArray<int, _OU_TARGET_ARCH__MAX - 1, const char *, 102>::m_aetElementArray[] = +{ + "OTHER", // _OU_TARGET_ARCH_OTHER + "x86", // _OU_TARGET_ARCH_X86 + "Itanium", // _OU_TARGET_ARCH_IA64 + "x64", // _OU_TARGET_ARCH_X64 + "PowerPC", // _OU_TARGET_ARCH_POWERPC + "Sparc", // _OU_TARGET_ARCH_SPARC + "ARM", // _OU_TARGET_ARCH_ARM +}; +static const CEnumUnsortedElementArray<int, _OU_TARGET_ARCH__MAX - 1, const char *, 102> g_aszArchitecturesNames; + +// Verifies that compilers order is not changed +template<> +int const CEnumSortedElementArray<int, _OU_COMPILER__MAX - 1, int, 103>::m_aetElementArray[] = +{ + _OU_COMPILER__OTHER, // _OU_COMPILER__OTHER, + _OU_COMPILER_GCC, // _OU_COMPILER_GCC, + _OU_COMPILER_MSVC, // _OU_COMPILER_MSVC, +}; +static const CEnumSortedElementArray<int, _OU_COMPILER__MAX - 1, int, 103> g_ai_CompilersOrderCheck; + +template<> +const char *const CEnumUnsortedElementArray<int, _OU_COMPILER__MAX - 1, const char *, 103>::m_aetElementArray[] = +{ + "UNKNOWN", // _OU_COMPILER__OTHER, + "GCC", // _OU_COMPILER_GCC, + "MSVC", // _OU_COMPILER_MSVC, +}; +static const CEnumUnsortedElementArray<int, _OU_COMPILER__MAX - 1, const char *, 103> g_aszCompilersNames; + +// Verifies that compiler versions order is not changed +template<> +int const CEnumSortedElementArray<int, _OU_COMPILER_VERSION__MAX - 1, int, 104>::m_aetElementArray[] = +{ + _OU_COMPILER_VERSION__OTHER, // _OU_COMPILER_VERSION__OTHER, + _OU_COMPILER_VERSION_MSVC1998, // _OU_COMPILER_VERSION_MSVC1998, + _OU_COMPILER_VERSION_GCCLT4, // _OU_COMPILER_VERSION_GCCLT4, +}; +static const CEnumSortedElementArray<int, _OU_COMPILER_VERSION__MAX - 1, int, 104> g_ai_CompilersVersionOrderCheck; + +template<> +const char *const CEnumUnsortedElementArray<int, _OU_COMPILER_VERSION__MAX - 1, const char *, 104>::m_aetElementArray[] = +{ + "OTHER", // _OU_COMPILER_VERSION__OTHER, + "MSVC1998", // _OU_COMPILER_VERSION_MSVC1998, + "GCC LESS THAN 4.0", // _OU_COMPILER_VERSION_GCCLT4, +}; +static const CEnumUnsortedElementArray<int, _OU_COMPILER_VERSION__MAX - 1, const char *, 104> g_aszCompilerVersionNames; + + +#define _TESTPLATFORM_DEFINITION_TEXT(Definition) #Definition +#define TESTPLATFORM_TEFINITION_TEXT(Definition) _TESTPLATFORM_DEFINITION_TEXT(Definition) + +bool TestPlatform(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount) +{ + const char *szOSName = g_aszOSNames.Encode(_OU_TARGET_OS - 1); + const char *szBitsName = g_aszBitsNames.Encode(_OU_TARGET_BITS - 1); + const char *szArchitectureName = g_aszArchitecturesNames.Encode(_OU_TARGET_ARCH - 1); + const char *szCompilerName = g_aszCompilersNames.Encode(_OU_COMPILER - 1); + const char *szCompilerVersion = g_aszCompilerVersionNames.Encode(_OU_COMPILER_VERSION - 1); + + printf("Target OS: %s\n", szOSName); + printf("Target Bits: %s\n", szBitsName); + printf("Target Architecture %s\n", szArchitectureName); + printf("Compiler Name: %s\n", szCompilerName); + printf("Compiler Version: %s\n", szCompilerVersion); + printf("Method Convention: %s\n", TESTPLATFORM_TEFINITION_TEXT(=_OU_CONVENTION_METHOD)); + printf("Function Convention: %s\n", TESTPLATFORM_TEFINITION_TEXT(=_OU_CONVENTION_API)); + printf("Callback Convention: %s\n", TESTPLATFORM_TEFINITION_TEXT(=_OU_CONVENTION_CALLBACK)); + printf("Alwaysinline definition: %s\n", TESTPLATFORM_TEFINITION_TEXT(=_OU_ALWAYSINLINE)); + printf("Inline definition: %s\n", TESTPLATFORM_TEFINITION_TEXT(=_OU_INLINE)); + + nOutSuccessCount = 0; + nOutTestCount = 0; + return true; +} + + +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////// + +enum EOUSUBSYSTEMTEST +{ + OST__MIN, + + OST_INTTYPES = OST__MIN, + OST_MACROS, + OST_TEMPLATES, + OST_TYPEWRAPPER, + OST_ASSERT, + OST_MALLOC, + OST_CUSTOMIZATION, + OST_ENUMARRAYS, +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS + OST_ATOMIC, +#endif + OST_FLAGSDEFINES, +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS + OST_ATOMICFLAGS, +#endif + OST_SIMPLEFLAGS64, + OST_SIMPLEFLAGS32, + OST_SIMPLEFLAGS16, + OST_SIMPLEFLAGS8, +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS + OST_TLS, +#endif + OST_PLATFORM, + + OST__MAX, +}; + +typedef bool (*COUSubsystemTestProcedure)(unsigned int &nOutSuccessCount, unsigned int &nOutTestCount); + +template<> +COUSubsystemTestProcedure const CEnumUnsortedElementArray<EOUSUBSYSTEMTEST, OST__MAX, COUSubsystemTestProcedure>::m_aetElementArray[] = +{ + &TestIntTypes, // OST_INTTYPES, + &TestMacros, // OST_MACROS, + &TestTemplates, // OST_TEMPLATES, + &TestTypeWrapper, // OST_TYPEWRAPPER, + &TestAssert, // OST_ASSERT, + &TestMalloc, // OST_MALLOC, + &TestCustomization, // OST_CUSTOMIZATION, + &TestEnumArrays, // OST_ENUMARRAYS, +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS + &TestAtomic, // OST_ATOMIC, +#endif + &TestFlagsDefines, // OST_FLAGSDEFINES, +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS + &TestAtomicFlags, // OST_ATOMICFLAGS, +#endif + &TestSimpleFlags64, // OST_SIMPLEFLAGS64, + &TestSimpleFlags32, // OST_SIMPLEFLAGS32, + &TestSimpleFlags16, // OST_SIMPLEFLAGS16, + &TestSimpleFlags8, // OST_SIMPLEFLAGS8, +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS + &TestTLS, // OST_TLS, +#endif + &TestPlatform, // OST_PLATFORM, +}; +static const CEnumUnsortedElementArray<EOUSUBSYSTEMTEST, OST__MAX, COUSubsystemTestProcedure> g_afnOUSubsystemTestProcedures; + +template<> +const char *const CEnumUnsortedElementArray<EOUSUBSYSTEMTEST, OST__MAX, const char *>::m_aetElementArray[] = +{ + "IntTypes", // OST_INTTYPES, + "Macros", // OST_MACROS, + "Templates", // OST_TEMPLATES, + "TypeWrapper", // OST_TYPEWRAPPER, + "Assert", // OST_ASSERT, + "Malloc", // OST_MALLOC, + "Customization", // OST_CUSTOMIZATION, + "EnumArrays", // OST_ENUMARRAYS, +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS + "Atomic", // OST_ATOMIC, +#endif + "FlagsDefines", // OST_FLAGSDEFINES, +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_ATOMICS + "AtomicFlags", // OST_ATOMICFLAGS, +#endif + "SimpleFlags64", // OST_SIMPLEFLAGS64, + "SimpleFlags32", // OST_SIMPLEFLAGS32, + "SimpleFlags16", // OST_SIMPLEFLAGS16, + "SimpleFlags8", // OST_SIMPLEFLAGS8, +#if _OU_FEATURE_SET >= _OU_FEATURE_SET_TLS + "TLS", // OST_TLS, +#endif + "Platform", // OST_PLATFORM, +}; +static const CEnumUnsortedElementArray<EOUSUBSYSTEMTEST, OST__MAX, const char *> g_aszOUSubsystemNames; + + +bool ProcessOUCoverageTests(unsigned int &nOutFailureCount) +{ + unsigned int nSuccessCount = 0; + + for (EOUSUBSYSTEMTEST stSubsystemTest = OST__MIN; stSubsystemTest != OST__MAX; ++stSubsystemTest) + { + const char *szSubsystemName = g_aszOUSubsystemNames.Encode(stSubsystemTest); + printf("\nTesting subsystem \"%s\"\n", szSubsystemName); + printf("---------------------------------------------------\n"); + + unsigned int nSubsysytemSuccessCount = 0, nSubsystemTestCount = 1; + + COUSubsystemTestProcedure fnTestProcedure = g_afnOUSubsystemTestProcedures.Encode(stSubsystemTest); + if (fnTestProcedure(nSubsysytemSuccessCount, nSubsystemTestCount) && nSubsysytemSuccessCount == nSubsystemTestCount) + { + nSuccessCount += 1; + } + + unsigned int nSubsysytemFailureCount = nSubsystemTestCount - nSubsysytemSuccessCount; + printf("---------------------------------------------------\n"); + printf("Feature tests failed: %3u out of %3u\n", nSubsysytemFailureCount, nSubsystemTestCount); + } + + unsigned int nFailureCount = OST__MAX - nSuccessCount; + + printf("\n===================================================\n"); + printf("Subsystem tests failed: %3u out of %3u\n", nFailureCount, (unsigned int)OST__MAX); + + nOutFailureCount = nFailureCount; + return nSuccessCount == OST__MAX; +} + +int main(int argc, char* argv[]) +{ + unsigned int nFailureCount; + ProcessOUCoverageTests(nFailureCount); + + return nFailureCount; +} + |