/* * test.cpp * -------- * Purpose: Unit tests for OpenMPT. * Notes : We need FAAAAAAAR more unit tests! * Authors: OpenMPT Devs * The OpenMPT source code is released under the BSD license. Read LICENSE for more details. */ #include "stdafx.h" #include "test.h" #ifdef ENABLE_TESTS #include "../common/version.h" #include "../common/misc_util.h" #include "../common/mptCRC.h" #include "../common/mptStringBuffer.h" #include "../common/serialization_utils.h" #include "../common/mptUUID.h" #include "../soundlib/Sndfile.h" #include "../common/FileReader.h" #include "../soundlib/mod_specifications.h" #include "../soundlib/MIDIEvents.h" #include "../soundlib/MIDIMacros.h" #include "../soundbase/SampleFormatConverters.h" #include "../soundbase/SampleFormatCopy.h" #include "../soundlib/ModSampleCopy.h" #include "../soundlib/ITCompression.h" #include "../soundlib/tuningcollection.h" #include "../soundlib/tuning.h" #include "../soundbase/Dither.h" #ifdef MODPLUG_TRACKER #include "../mptrack/Mptrack.h" #include "../mptrack/Moddoc.h" #include "../mptrack/ModDocTemplate.h" #include "../mptrack/Mainfrm.h" #include "../mptrack/Settings.h" #include "../mptrack/HTTP.h" #endif // MODPLUG_TRACKER #include "../common/mptFileIO.h" #ifdef LIBOPENMPT_BUILD #include "../libopenmpt/libopenmpt_version.h" #endif // LIBOPENMPT_BUILD #ifndef NO_PLUGINS #include "../soundlib/plugins/PlugInterface.h" #endif #include #include #ifdef LIBOPENMPT_BUILD #include #endif // LIBOPENMPT_BUILD #include #include #include #if MPT_COMPILER_MSVC #include #endif #if MPT_OS_WINDOWS #include #endif #if defined(MPT_WITH_ZLIB) #include #elif defined(MPT_WITH_MINIZ) #define MINIZ_NO_ZLIB_COMPATIBLE_NAMES #include #endif #define MPT_TEST_HAS_FILESYSTEM 1 #if MPT_OS_DJGPP #undef MPT_TEST_HAS_FILESYSTEM #define MPT_TEST_HAS_FILESYSTEM 0 #endif #if MPT_COMPILER_MSVC && defined(MPT_WITH_MFC) && defined(_DEBUG) #define new DEBUG_NEW #endif #include "TestTools.h" // enable tests which may fail spuriously //#define FLAKY_TESTS OPENMPT_NAMESPACE_BEGIN namespace Test { static MPT_NOINLINE void TestVersion(); static MPT_NOINLINE void TestTypes(); static MPT_NOINLINE void TestMisc1(); static MPT_NOINLINE void TestMisc2(); static MPT_NOINLINE void TestRandom(); static MPT_NOINLINE void TestCharsets(); static MPT_NOINLINE void TestStringFormatting(); static MPT_NOINLINE void TestSettings(); static MPT_NOINLINE void TestStringIO(); static MPT_NOINLINE void TestMIDIEvents(); static MPT_NOINLINE void TestSampleConversion(); static MPT_NOINLINE void TestITCompression(); static MPT_NOINLINE void TestTunings(); static MPT_NOINLINE void TestPCnoteSerialization(); static MPT_NOINLINE void TestLoadSaveFile(); static MPT_NOINLINE void TestEditing(); static mpt::PathString *PathPrefix = nullptr; static mpt::default_prng * s_PRNG = nullptr; mpt::PathString GetPathPrefix() { if((*PathPrefix).empty()) { return P_(""); } return *PathPrefix + P_("/"); } void DoTests() { #ifdef LIBOPENMPT_BUILD std::cout << std::flush; std::clog << std::flush; std::cerr << std::flush; std::cout << "libopenmpt test suite" << std::endl; std::cout << "Version.: " << mpt::ToCharset(mpt::Charset::ASCII, Build::GetVersionString(Build::StringVersion | Build::StringRevision | Build::StringBitness | Build::StringSourceInfo | Build::StringBuildFlags | Build::StringBuildFeatures)) << std::endl; std::cout << "Compiler: " << mpt::ToCharset(mpt::Charset::ASCII, Build::GetBuildCompilerString()) << std::endl; #if MPT_OS_WINDOWS std::cout << "Required Windows Kernel Level: " << mpt::ToCharset(mpt::Charset::ASCII, mpt::Windows::Version::VersionToString(mpt::Windows::Version::GetMinimumKernelLevel())) << std::endl; std::cout << "Required Windows API Level...: " << mpt::ToCharset(mpt::Charset::ASCII, mpt::Windows::Version::VersionToString(mpt::Windows::Version::GetMinimumAPILevel())) << std::endl; std::cout << "Windows.: " << mpt::ToCharset(mpt::Charset::ASCII, mpt::Windows::Version::Current().GetName()) << std::endl; #endif std::cout << std::flush; #endif #if MPT_OS_WINDOWS // prefix for test suite std::wstring pathprefix = std::wstring(); bool libopenmpt = false; #ifdef LIBOPENMPT_BUILD libopenmpt = true; #endif #if !MPT_OS_WINDOWS_WINRT // set path prefix for test files (if provided) std::vector buf(GetEnvironmentVariableW(L"srcdir", NULL, 0) + 1); if(GetEnvironmentVariableW(L"srcdir", buf.data(), static_cast(buf.size())) > 0) { pathprefix = buf.data(); } else #endif if(libopenmpt && IsDebuggerPresent()) { pathprefix = L"../../"; } PathPrefix = new mpt::PathString(mpt::PathString::FromWide(pathprefix)); #else // prefix for test suite std::string pathprefix = std::string(); // set path prefix for test files (if provided) std::string env_srcdir = mpt::getenv( "srcdir" ); if ( !env_srcdir.empty() ) { pathprefix = env_srcdir; } PathPrefix = new mpt::PathString(mpt::PathString::FromNative(pathprefix)); #endif mpt::random_device rd; s_PRNG = new mpt::default_prng(mpt::make_prng(rd)); DO_TEST(TestVersion); DO_TEST(TestTypes); DO_TEST(TestMisc1); DO_TEST(TestMisc2); DO_TEST(TestRandom); DO_TEST(TestCharsets); DO_TEST(TestStringFormatting); DO_TEST(TestSettings); DO_TEST(TestStringIO); DO_TEST(TestMIDIEvents); DO_TEST(TestSampleConversion); DO_TEST(TestITCompression); DO_TEST(TestTunings); // slower tests, require opening a CModDoc DO_TEST(TestPCnoteSerialization); DO_TEST(TestLoadSaveFile); DO_TEST(TestEditing); delete s_PRNG; s_PRNG = nullptr; delete PathPrefix; PathPrefix = nullptr; } static mpt::PathString GetTempFilenameBase(); static void RemoveFile(const mpt::PathString &filename) { #if MPT_OS_WINDOWS for(int retry=0; retry<10; retry++) { if(DeleteFile(filename.AsNative().c_str()) != FALSE) { break; } // wait for windows virus scanners Sleep(10); } #else remove(filename.AsNative().c_str()); #endif } // Test if functions related to program version data work static MPT_NOINLINE void TestVersion() { //Verify that macros and functions work. { VERIFY_EQUAL( Version::Parse(Version::Current().ToUString()), Version::Current() ); VERIFY_EQUAL( Version::Parse(Version::Current().ToUString()).ToUString(), Version::Current().ToUString() ); VERIFY_EQUAL( Version(18285096).ToUString(), U_("1.17.02.28") ); VERIFY_EQUAL( Version::Parse(U_("1.17.02.28")), Version(18285096) ); VERIFY_EQUAL( Version::Parse(U_("1.fe.02.28")), Version(0x01fe0228) ); VERIFY_EQUAL( Version::Parse(U_("01.fe.02.28")), Version(0x01fe0228) ); VERIFY_EQUAL( Version::Parse(U_("1.22")), Version(0x01220000) ); VERIFY_EQUAL( MPT_V("1.17.02.28"), Version(18285096) ); VERIFY_EQUAL( MPT_V("1.fe.02.28"), Version(0x01fe0228) ); VERIFY_EQUAL( MPT_V("01.fe.02.28"), Version(0x01fe0228) ); VERIFY_EQUAL( MPT_V("1.22"), Version(0x01220000) ); VERIFY_EQUAL( MPT_V("1.19.02.00").WithoutTestNumber(), MPT_V("1.19.02.00")); VERIFY_EQUAL( MPT_V("1.18.03.20").WithoutTestNumber(), MPT_V("1.18.03.00")); VERIFY_EQUAL( MPT_V("1.18.01.13").IsTestVersion(), true); VERIFY_EQUAL( MPT_V("1.19.01.00").IsTestVersion(), false); VERIFY_EQUAL( MPT_V("1.17.02.54").IsTestVersion(), false); VERIFY_EQUAL( MPT_V("1.18.00.00").IsTestVersion(), false); VERIFY_EQUAL( MPT_V("1.18.02.00").IsTestVersion(), false); VERIFY_EQUAL( MPT_V("1.18.02.01").IsTestVersion(), true); // Ensure that versions ending in .00.00 (which are ambiguous to truncated version numbers in certain file formats (e.g. S3M and IT) do not get qualified as test builds. VERIFY_EQUAL( MPT_V("1.23.00.00").IsTestVersion(), false); static_assert( MPT_V("1.17.2.28").GetRawVersion() == 18285096 ); static_assert( MPT_V("1.17.02.48").GetRawVersion() == 18285128 ); static_assert( MPT_V("01.17.02.52").GetRawVersion() == 18285138 ); // Ensure that bit-shifting works (used in some mod loaders for example) static_assert( MPT_V("01.17.00.00").GetRawVersion() == 0x0117 << 16 ); static_assert( MPT_V("01.17.03.00").GetRawVersion() >> 8 == 0x011703 ); } #ifdef MODPLUG_TRACKER //Verify that the version obtained from the executable file is the same as //defined in Version. { WCHAR szFullPath[MAX_PATH]; DWORD dwVerHnd; DWORD dwVerInfoSize; // Get version information from the application ::GetModuleFileNameW(NULL, szFullPath, mpt::saturate_cast(std::size(szFullPath))); dwVerInfoSize = ::GetFileVersionInfoSizeW(szFullPath, &dwVerHnd); if (!dwVerInfoSize) throw std::runtime_error("!dwVerInfoSize is true"); std::vector pVersionInfo(dwVerInfoSize); WCHAR *szVer = nullptr; UINT uVerLength; if (!(::GetFileVersionInfoW(szFullPath, (DWORD)dwVerHnd, (DWORD)dwVerInfoSize, pVersionInfo.data()))) { throw std::runtime_error("GetFileVersionInfo() returned false"); } if (!(::VerQueryValueW(pVersionInfo.data(), L"\\StringFileInfo\\040904b0\\FileVersion", (LPVOID*)&szVer, &uVerLength))) { throw std::runtime_error("VerQueryValue() returned false"); } mpt::ustring version = mpt::ToUnicode(szVer); VERIFY_EQUAL( version, mpt::ufmt::val(Version::Current()) ); VERIFY_EQUAL( Version::Parse(version), Version::Current() ); } #endif #ifdef LIBOPENMPT_BUILD #if MPT_TEST_HAS_FILESYSTEM #if !MPT_OS_DJGPP mpt::PathString version_mk = GetPathPrefix() + P_("libopenmpt/libopenmpt_version.mk"); mpt::ifstream f(version_mk, std::ios::in); VERIFY_EQUAL(f ? true : false, true); std::map fields; std::string line; while(std::getline(f, line)) { line = mpt::String::Trim(line); if(line.empty()) { continue; } std::vector line_fields = mpt::String::Split(line, std::string("=")); VERIFY_EQUAL_NONCONT(line_fields.size(), 2u); line_fields[0] = mpt::String::Trim(line_fields[0]); line_fields[1] = mpt::String::Trim(line_fields[1]); VERIFY_EQUAL_NONCONT(line_fields[0].length() > 0, true); fields[line_fields[0]] = line_fields[1]; } VERIFY_EQUAL(fields["LIBOPENMPT_VERSION_MAJOR"], mpt::fmt::val(OPENMPT_API_VERSION_MAJOR)); VERIFY_EQUAL(fields["LIBOPENMPT_VERSION_MINOR"], mpt::fmt::val(OPENMPT_API_VERSION_MINOR)); VERIFY_EQUAL(fields["LIBOPENMPT_VERSION_PATCH"], mpt::fmt::val(OPENMPT_API_VERSION_PATCH)); VERIFY_EQUAL(fields["LIBOPENMPT_VERSION_PREREL"], mpt::fmt::val(OPENMPT_API_VERSION_PREREL)); if(std::string(OPENMPT_API_VERSION_PREREL).length() > 0) { VERIFY_EQUAL(std::string(OPENMPT_API_VERSION_PREREL).substr(0, 1), "-"); } VERIFY_EQUAL(OPENMPT_API_VERSION_IS_PREREL, (std::string(OPENMPT_API_VERSION_PREREL).length() > 0) ? 1 : 0); VERIFY_EQUAL(fields["LIBOPENMPT_LTVER_CURRENT"].length() > 0, true); VERIFY_EQUAL(fields["LIBOPENMPT_LTVER_REVISION"].length() > 0, true); VERIFY_EQUAL(fields["LIBOPENMPT_LTVER_AGE"].length() > 0, true); #endif // !MPT_OS_DJGPP #endif // MPT_TEST_HAS_FILESYSTEM #endif // LIBOPENMPT_BUILD } // Test if data types are interpreted correctly static MPT_NOINLINE void TestTypes() { static_assert(sizeof(std::uintptr_t) == sizeof(void*)); #if defined(__SIZEOF_POINTER__) static_assert(__SIZEOF_POINTER__ == mpt::pointer_size); static_assert(__SIZEOF_POINTER__ == sizeof(void*)); #endif VERIFY_EQUAL(int8_min, (std::numeric_limits::min)()); VERIFY_EQUAL(int8_max, (std::numeric_limits::max)()); VERIFY_EQUAL(uint8_max, (std::numeric_limits::max)()); VERIFY_EQUAL(int16_min, (std::numeric_limits::min)()); VERIFY_EQUAL(int16_max, (std::numeric_limits::max)()); VERIFY_EQUAL(uint16_max, (std::numeric_limits::max)()); VERIFY_EQUAL(int32_min, (std::numeric_limits::min)()); VERIFY_EQUAL(int32_max, (std::numeric_limits::max)()); VERIFY_EQUAL(uint32_max, (std::numeric_limits::max)()); VERIFY_EQUAL(int64_min, (std::numeric_limits::min)()); VERIFY_EQUAL(int64_max, (std::numeric_limits::max)()); VERIFY_EQUAL(uint64_max, (std::numeric_limits::max)()); static_assert(int8_max == (std::numeric_limits::max)()); static_assert(uint8_max == (std::numeric_limits::max)()); static_assert(int16_max == (std::numeric_limits::max)()); static_assert(uint16_max == (std::numeric_limits::max)()); static_assert(int32_max == (std::numeric_limits::max)()); static_assert(uint32_max == (std::numeric_limits::max)()); static_assert(int64_max == (std::numeric_limits::max)()); static_assert(uint64_max == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::min)() == (std::numeric_limits::min)()); static_assert((mpt::limits::min)() == (std::numeric_limits::min)()); static_assert((mpt::limits::min)() == (std::numeric_limits::min)()); static_assert((mpt::limits::min)() == (std::numeric_limits::min)()); static_assert((mpt::limits::min)() == (std::numeric_limits::min)()); static_assert((mpt::limits::min)() == (std::numeric_limits::min)()); static_assert((mpt::limits::min)() == (std::numeric_limits::min)()); static_assert((mpt::limits::min)() == (std::numeric_limits::min)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); static_assert((mpt::limits::max)() == (std::numeric_limits::max)()); } #ifdef MODPLUG_TRACKER // In tracker debug builds, the sprintf-like function is retained in order to be able to validate our own formatting against sprintf. // There are 4 reasons why this is not available for library code: // 1. printf-like functionality is not type-safe. // 2. There are portability problems with char/wchar_t and the semantics of %s/%ls/%S . // 3. There are portability problems with specifying format for 64bit integers. // 4. Formatting of floating point values depends on the currently set C locale. // A library is not allowed to mock with that and thus cannot influence the behavior in this case. template static std::string StringFormat(const char *format, T x) { #if MPT_COMPILER_MSVC // Count the needed array size. const size_t nCount = _scprintf(format, x); // null character not included. std::vector buf(nCount + 1); // + 1 is for null terminator. sprintf_s(&(buf[0]), buf.size(), format, x); return &(buf[0]); #else int size = snprintf(NULL, 0, format, x); // get required size, requires c99 compliant snprintf which msvc does not have std::vector temp(size + 1); snprintf(&(temp[0]), size + 1, format, x); return &(temp[0]); #endif } #endif template static void TestFloatFormat(Tfloat x, const char * format, mpt::FormatFlags f, std::size_t width = 0, int precision = -1) { #ifdef MODPLUG_TRACKER std::string str_sprintf = StringFormat(format, x); #endif std::string str_iostreams = mpt::fmt::fmt(x, mpt::FormatSpec().SetFlags(f).SetWidth(width).SetPrecision(precision)); //Log("%s", str_sprintf.c_str()); //Log("%s", str_iostreams.c_str()); //Log("%s", str_iostreams.c_str()); #ifdef MODPLUG_TRACKER VERIFY_EQUAL(str_iostreams, str_sprintf); // this will fail with a set c locale (and there is nothing that can be done about that in libopenmpt) #else MPT_UNREFERENCED_PARAMETER(format); MPT_UNUSED_VARIABLE(str_iostreams); #endif } template static void TestFloatFormats(Tfloat x) { TestFloatFormat(x, "%g", mpt::fmt::NotaNrm | mpt::fmt::FillOff); TestFloatFormat(x, "%.8g", mpt::fmt::NotaNrm | mpt::fmt::FillOff, 0, 8); TestFloatFormat(x, "%f", mpt::fmt::NotaFix | mpt::fmt::FillOff); TestFloatFormat(x, "%.0f", mpt::fmt::NotaFix | mpt::fmt::FillOff, 0, 0); TestFloatFormat(x, "%.1f", mpt::fmt::NotaFix | mpt::fmt::FillOff, 0, 1); TestFloatFormat(x, "%.2f", mpt::fmt::NotaFix | mpt::fmt::FillOff, 0, 2); TestFloatFormat(x, "%.3f", mpt::fmt::NotaFix | mpt::fmt::FillOff, 0, 3); TestFloatFormat(x, "%0.1f", mpt::fmt::NotaFix | mpt::fmt::FillNul, 0, 1); TestFloatFormat(x, "%02.0f", mpt::fmt::NotaFix | mpt::fmt::FillNul, 2, 0); } static bool BeginsWith(const std::string &str, const std::string &match) { return (str.find(match) == 0); } static bool EndsWith(const std::string &str, const std::string &match) { return (str.rfind(match) == (str.length() - match.length())); } #if MPT_WSTRING_CONVERT static bool BeginsWith(const std::wstring &str, const std::wstring &match) { return (str.find(match) == 0); } static bool EndsWith(const std::wstring &str, const std::wstring &match) { return (str.rfind(match) == (str.length() - match.length())); } #endif #if MPT_USTRING_MODE_UTF8 static bool BeginsWith(const mpt::ustring &str, const mpt::ustring &match) { return (str.find(match) == 0); } static bool EndsWith(const mpt::ustring &str, const mpt::ustring &match) { return (str.rfind(match) == (str.length() - match.length())); } #endif static MPT_NOINLINE void TestStringFormatting() { VERIFY_EQUAL(mpt::fmt::val(1.5f), "1.5"); VERIFY_EQUAL(mpt::fmt::val(true), "1"); VERIFY_EQUAL(mpt::fmt::val(false), "0"); //VERIFY_EQUAL(mpt::fmt::val('A'), "A"); // deprecated //VERIFY_EQUAL(mpt::fmt::val(L'A'), "A"); // deprecated VERIFY_EQUAL(mpt::fmt::val(0), "0"); VERIFY_EQUAL(mpt::fmt::val(-23), "-23"); VERIFY_EQUAL(mpt::fmt::val(42), "42"); VERIFY_EQUAL(mpt::fmt::hex0<3>((int32)-1), "-001"); VERIFY_EQUAL(mpt::fmt::hex((int32)-1), "-1"); VERIFY_EQUAL(mpt::fmt::hex(-0xabcde), "-abcde"); VERIFY_EQUAL(mpt::fmt::hex(int32_min), "-80000000"); VERIFY_EQUAL(mpt::fmt::hex(int32_min + 1), "-7fffffff"); VERIFY_EQUAL(mpt::fmt::hex(0x123e), "123e"); VERIFY_EQUAL(mpt::fmt::hex0<6>(0x123e), "00123e"); VERIFY_EQUAL(mpt::fmt::hex0<2>(0x123e), "123e"); VERIFY_EQUAL(mpt::fmt::dec0<0>(1), "1"); VERIFY_EQUAL(mpt::fmt::dec0<1>(1), "1"); VERIFY_EQUAL(mpt::fmt::dec0<2>(1), "01"); VERIFY_EQUAL(mpt::fmt::dec0<3>(1), "001"); VERIFY_EQUAL(mpt::fmt::dec0<0>(11), "11"); VERIFY_EQUAL(mpt::fmt::dec0<1>(11), "11"); VERIFY_EQUAL(mpt::fmt::dec0<2>(11), "11"); VERIFY_EQUAL(mpt::fmt::dec0<3>(11), "011"); VERIFY_EQUAL(mpt::fmt::dec0<0>(-1), "-1"); VERIFY_EQUAL(mpt::fmt::dec0<1>(-1), "-1"); VERIFY_EQUAL(mpt::fmt::dec0<2>(-1), "-01"); VERIFY_EQUAL(mpt::fmt::dec0<3>(-1), "-001"); VERIFY_EQUAL(mpt::ufmt::HEX0<7>(0xa2345678), U_("A2345678")); VERIFY_EQUAL(mpt::ufmt::HEX0<8>(0xa2345678), U_("A2345678")); VERIFY_EQUAL(mpt::ufmt::HEX0<9>(0xa2345678), U_("0A2345678")); VERIFY_EQUAL(mpt::ufmt::HEX0<10>(0xa2345678), U_("00A2345678")); #if MPT_WSTRING_FORMAT VERIFY_EQUAL(mpt::wfmt::hex(0x123e), L"123e"); VERIFY_EQUAL(mpt::wfmt::hex0<6>(0x123e), L"00123e"); VERIFY_EQUAL(mpt::wfmt::hex0<2>(0x123e), L"123e"); #endif VERIFY_EQUAL(mpt::fmt::val(-87.0f), "-87"); if(mpt::fmt::val(-0.5e-6) != "-5e-007" && mpt::fmt::val(-0.5e-6) != "-5e-07" && mpt::fmt::val(-0.5e-6) != "-5e-7" ) { VERIFY_EQUAL(true, false); } VERIFY_EQUAL(mpt::fmt::val(58.65403492763), "58.654"); VERIFY_EQUAL(mpt::fmt::fix(23.42, 1), "23.4"); VERIFY_EQUAL(mpt::fmt::fix(234.2, 1), "234.2"); VERIFY_EQUAL(mpt::fmt::fix(2342.0, 1), "2342.0"); VERIFY_EQUAL(mpt::fmt::dec(2, ';', 2345678), std::string("2;34;56;78")); VERIFY_EQUAL(mpt::fmt::dec(2, ';', 12345678), std::string("12;34;56;78")); VERIFY_EQUAL(mpt::fmt::hex(3, ':', 0xa2345678), std::string("a2:345:678")); VERIFY_EQUAL(mpt::ufmt::dec(2, ';', 12345678), U_("12;34;56;78")); VERIFY_EQUAL(mpt::ufmt::hex(3, ':', 0xa2345678), U_("a2:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<7>(3, ':', 0xa2345678), U_("A2:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<8>(3, ':', 0xa2345678), U_("A2:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<9>(3, ':', 0xa2345678), U_("0A2:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<10>(3, ':', 0xa2345678), U_("0:0A2:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<11>(3, ':', 0xa2345678), U_("00:0A2:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<12>(3, ':', 0xa2345678), U_("000:0A2:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<7>(3, ':', -0x12345678), U_("-12:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<8>(3, ':', -0x12345678), U_("-12:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<9>(3, ':', -0x12345678), U_("-012:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<10>(3, ':', -0x12345678), U_("-0:012:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<11>(3, ':', -0x12345678), U_("-00:012:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<12>(3, ':', -0x12345678), U_("-000:012:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<5>(3, ':', 0x345678), U_("345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<6>(3, ':', 0x345678), U_("345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<7>(3, ':', 0x345678), U_("0:345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<5>(3, ':', -0x345678), U_("-345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<6>(3, ':', -0x345678), U_("-345:678")); VERIFY_EQUAL(mpt::ufmt::HEX0<7>(3, ':', -0x345678), U_("-0:345:678")); VERIFY_EQUAL(mpt::fmt::left(3, "a"), "a "); VERIFY_EQUAL(mpt::fmt::right(3, "a"), " a"); VERIFY_EQUAL(mpt::fmt::center(3, "a"), " a "); VERIFY_EQUAL(mpt::fmt::center(4, "a"), " a "); #if defined(MPT_WITH_MFC) VERIFY_EQUAL(mpt::cfmt::left(3, CString(_T("a"))), CString(_T("a "))); VERIFY_EQUAL(mpt::cfmt::right(3, CString(_T("a"))), CString(_T(" a"))); VERIFY_EQUAL(mpt::cfmt::center(3, CString(_T("a"))), CString(_T(" a "))); VERIFY_EQUAL(mpt::cfmt::center(4, CString(_T("a"))), CString(_T(" a "))); #endif // MPT_WITH_MFC VERIFY_EQUAL(ConvertStrTo("586"), 586u); VERIFY_EQUAL(ConvertStrTo("2147483647"), (uint32)int32_max); VERIFY_EQUAL(ConvertStrTo("4294967295"), uint32_max); VERIFY_EQUAL(ConvertStrTo("-9223372036854775808"), int64_min); VERIFY_EQUAL(ConvertStrTo("-159"), -159); VERIFY_EQUAL(ConvertStrTo("9223372036854775807"), int64_max); VERIFY_EQUAL(ConvertStrTo("85059"), 85059u); VERIFY_EQUAL(ConvertStrTo("9223372036854775807"), (uint64)int64_max); VERIFY_EQUAL(ConvertStrTo("18446744073709551615"), uint64_max); VERIFY_EQUAL(ConvertStrTo("-87.0"), -87.0f); #if !MPT_OS_DJGPP VERIFY_EQUAL(ConvertStrTo("-0.5e-6"), -0.5e-6); #endif #if !MPT_OS_DJGPP VERIFY_EQUAL(ConvertStrTo("58.65403492763"), 58.65403492763); #else VERIFY_EQUAL_EPS(ConvertStrTo("58.65403492763"), 58.65403492763, 0.0001); #endif VERIFY_EQUAL(ConvertStrTo(mpt::fmt::val(-87.0)), -87.0f); #if !MPT_OS_DJGPP VERIFY_EQUAL(ConvertStrTo(mpt::fmt::val(-0.5e-6)), -0.5e-6); #endif VERIFY_EQUAL(mpt::String::Parse::Hex("fe"), 254); #if MPT_WSTRING_FORMAT VERIFY_EQUAL(mpt::String::Parse::Hex(L"fe"), 254); #endif VERIFY_EQUAL(mpt::String::Parse::Hex(U_("ffff")), 65535); TestFloatFormats(0.0f); TestFloatFormats(1.0f); TestFloatFormats(-1.0f); TestFloatFormats(0.1f); TestFloatFormats(-0.1f); TestFloatFormats(1000000000.0f); TestFloatFormats(-1000000000.0f); TestFloatFormats(0.0000000001f); TestFloatFormats(-0.0000000001f); TestFloatFormats(6.12345f); TestFloatFormats(0.0); TestFloatFormats(1.0); TestFloatFormats(-1.0); TestFloatFormats(0.1); TestFloatFormats(-0.1); TestFloatFormats(1000000000.0); TestFloatFormats(-1000000000.0); TestFloatFormats(0.0000000001); TestFloatFormats(-0.0000000001); TestFloatFormats(6.12345); TestFloatFormats(42.1234567890); TestFloatFormats(0.1234567890); TestFloatFormats(1234567890000000.0); TestFloatFormats(0.0000001234567890); VERIFY_EQUAL(mpt::fmt::flt(6.12345, 3), "6.12"); VERIFY_EQUAL(mpt::fmt::fix(6.12345, 3), "6.123"); VERIFY_EQUAL(mpt::fmt::flt(6.12345, 4), "6.123"); VERIFY_EQUAL(mpt::fmt::fix(6.12345, 4), "6.1235"); #if MPT_WSTRING_FORMAT VERIFY_EQUAL(mpt::wfmt::flt(6.12345, 3), L"6.12"); VERIFY_EQUAL(mpt::wfmt::fix(6.12345, 3), L"6.123"); VERIFY_EQUAL(mpt::wfmt::flt(6.12345, 4), L"6.123"); #endif // basic VERIFY_EQUAL(mpt::format("%1%2%3")(1,2,3), "123"); VERIFY_EQUAL(mpt::format("%1%1%1")(1,2,3), "111"); VERIFY_EQUAL(mpt::format("%3%3%3")(1,2,3), "333"); // template argument deduction of string type VERIFY_EQUAL(mpt::format(std::string("%1%2%3"))(1,2,3), "123"); #if MPT_WSTRING_FORMAT VERIFY_EQUAL(mpt::format(L"%1%2%3")(1,2,3), L"123"); VERIFY_EQUAL(mpt::format(L"%1%2%3")(1,2,3), L"123"); #endif // escaping and error behviour of '%' VERIFY_EQUAL(mpt::format("%")(), "%"); VERIFY_EQUAL(mpt::format("%%")(), "%"); VERIFY_EQUAL(mpt::format("%%%")(), "%%"); VERIFY_EQUAL(mpt::format("%1")("a"), "a"); VERIFY_EQUAL(mpt::format("%1%")("a"), "a%"); VERIFY_EQUAL(mpt::format("%1%%")("a"), "a%"); VERIFY_EQUAL(mpt::format("%1%%%")("a"), "a%%"); VERIFY_EQUAL(mpt::format("%%1")("a"), "%1"); VERIFY_EQUAL(mpt::format("%%%1")("a"), "%a"); VERIFY_EQUAL(mpt::format("%b")("a"), "%b"); #if defined(MPT_WITH_MFC) VERIFY_EQUAL(mpt::ufmt::val(CString(_T("foobar"))), U_("foobar")); VERIFY_EQUAL(mpt::ufmt::val(CString(_T("foobar"))), U_("foobar")); VERIFY_EQUAL(mpt::format(CString(_T("%1%2%3")))(1,2,3), _T("123")); VERIFY_EQUAL(mpt::format(CString(_T("%1%2%3")))(1,mpt::cfmt::dec0<3>(2),3), _T("10023")); #endif // MPT_WITH_MFC } struct Gregorian { int Y,M,D,h,m,s; static Gregorian FromTM(tm t) { Gregorian g; g.Y = t.tm_year + 1900; g.M = t.tm_mon + 1; g.D = t.tm_mday; g.h = t.tm_hour; g.m = t.tm_min; g.s = t.tm_sec; return g; } static tm ToTM(Gregorian g) { tm t; MemsetZero(t); t.tm_year = g.Y - 1900; t.tm_mon = g.M - 1; t.tm_mday = g.D; t.tm_hour = g.h; t.tm_min = g.m; t.tm_sec = g.s; return t; } }; bool operator ==(Gregorian a, Gregorian b) { return a.Y == b.Y && a.M == b.M && a.D == b.D && a.h == b.h && a.m == b.m && a.s == b.s; } bool operator !=(Gregorian a, Gregorian b) { return !(a == b); } int64 TestDate1(int s, int m, int h, int D, int M, int Y) { return mpt::Date::Unix::FromUTC(Gregorian::ToTM(Gregorian{Y,M,D,h,m,s})); } Gregorian TestDate2(int s, int m, int h, int D, int M, int Y) { return Gregorian{Y,M,D,h,m,s}; } static MPT_CONSTEXPR20_FUN int32le TestEndianConstexpr(uint32 x) { int32le foo{}; foo = x; return foo; } static MPT_NOINLINE void TestMisc1() { #if MPT_CXX_BEFORE(20) VERIFY_EQUAL(mpt::get_endian(), mpt::detail::endian_probe()); #endif MPT_MAYBE_CONSTANT_IF(mpt::endian_is_little()) { VERIFY_EQUAL(mpt::get_endian(), mpt::endian::little); MPT_MAYBE_CONSTANT_IF((mpt::endian::native == mpt::endian::little) || (mpt::endian::native == mpt::endian::big)) { VERIFY_EQUAL(mpt::endian::native, mpt::endian::little); } #if MPT_CXX_BEFORE(20) VERIFY_EQUAL(mpt::detail::endian_probe(), mpt::endian::little); #endif } MPT_MAYBE_CONSTANT_IF(mpt::endian_is_big()) { VERIFY_EQUAL(mpt::get_endian(), mpt::endian::big); MPT_MAYBE_CONSTANT_IF((mpt::endian::native == mpt::endian::little) || (mpt::endian::native == mpt::endian::big)) { VERIFY_EQUAL(mpt::endian::native, mpt::endian::big); } #if MPT_CXX_BEFORE(20) VERIFY_EQUAL(mpt::detail::endian_probe(), mpt::endian::big); #endif } MPT_CONSTEXPR20_VAR int32le foo = TestEndianConstexpr(23); static_cast(foo); VERIFY_EQUAL(mpt::detail::SwapBytes(uint8(0x12)), 0x12); VERIFY_EQUAL(mpt::detail::SwapBytes(uint16(0x1234)), 0x3412); VERIFY_EQUAL(mpt::detail::SwapBytes(uint32(0x12345678u)), 0x78563412u); VERIFY_EQUAL(mpt::detail::SwapBytes(uint64(0x123456789abcdef0ull)), 0xf0debc9a78563412ull); VERIFY_EQUAL(mpt::detail::SwapBytes(int8(int8_min)), int8_min); VERIFY_EQUAL(mpt::detail::SwapBytes(int16(int16_min)), int16(0x80)); VERIFY_EQUAL(mpt::detail::SwapBytes(int32(int32_min)), int32(0x80)); VERIFY_EQUAL(mpt::detail::SwapBytes(int64(int64_min)), int64(0x80)); VERIFY_EQUAL(EncodeIEEE754binary32(1.0f), 0x3f800000u); VERIFY_EQUAL(EncodeIEEE754binary32(-1.0f), 0xbf800000u); VERIFY_EQUAL(DecodeIEEE754binary32(0x00000000u), 0.0f); VERIFY_EQUAL(DecodeIEEE754binary32(0x41840000u), 16.5f); VERIFY_EQUAL(DecodeIEEE754binary32(0x3faa0000u), 1.328125f); VERIFY_EQUAL(DecodeIEEE754binary32(0xbfaa0000u), -1.328125f); VERIFY_EQUAL(DecodeIEEE754binary32(0x3f800000u), 1.0f); VERIFY_EQUAL(DecodeIEEE754binary32(0x00000000u), 0.0f); VERIFY_EQUAL(DecodeIEEE754binary32(0xbf800000u), -1.0f); VERIFY_EQUAL(DecodeIEEE754binary32(0x3f800000u), 1.0f); VERIFY_EQUAL(IEEE754binary32LE(1.0f).GetInt32(), 0x3f800000u); VERIFY_EQUAL(IEEE754binary32BE(1.0f).GetInt32(), 0x3f800000u); VERIFY_EQUAL(IEEE754binary32LE(mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x80),mpt::as_byte(0x3f)), 1.0f); VERIFY_EQUAL(IEEE754binary32BE(mpt::as_byte(0x3f),mpt::as_byte(0x80),mpt::as_byte(0x00),mpt::as_byte(0x00)), 1.0f); VERIFY_EQUAL(IEEE754binary32LE(1.0f), IEEE754binary32LE(mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x80),mpt::as_byte(0x3f))); VERIFY_EQUAL(IEEE754binary32BE(1.0f), IEEE754binary32BE(mpt::as_byte(0x3f),mpt::as_byte(0x80),mpt::as_byte(0x00),mpt::as_byte(0x00))); VERIFY_EQUAL(EncodeIEEE754binary64(1.0), 0x3ff0000000000000ull); VERIFY_EQUAL(EncodeIEEE754binary64(-1.0), 0xbff0000000000000ull); VERIFY_EQUAL(DecodeIEEE754binary64(0x0000000000000000ull), 0.0); VERIFY_EQUAL(DecodeIEEE754binary64(0x4030800000000000ull), 16.5); VERIFY_EQUAL(DecodeIEEE754binary64(0x3FF5400000000000ull), 1.328125); VERIFY_EQUAL(DecodeIEEE754binary64(0xBFF5400000000000ull), -1.328125); VERIFY_EQUAL(DecodeIEEE754binary64(0x3ff0000000000000ull), 1.0); VERIFY_EQUAL(DecodeIEEE754binary64(0x0000000000000000ull), 0.0); VERIFY_EQUAL(DecodeIEEE754binary64(0xbff0000000000000ull), -1.0); VERIFY_EQUAL(DecodeIEEE754binary64(0x3ff0000000000000ull), 1.0); VERIFY_EQUAL(IEEE754binary64LE(1.0).GetInt64(), 0x3ff0000000000000ull); VERIFY_EQUAL(IEEE754binary64BE(1.0).GetInt64(), 0x3ff0000000000000ull); VERIFY_EQUAL(IEEE754binary64LE(mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0xf0),mpt::as_byte(0x3f)), 1.0); VERIFY_EQUAL(IEEE754binary64BE(mpt::as_byte(0x3f),mpt::as_byte(0xf0),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00)), 1.0); VERIFY_EQUAL(IEEE754binary64LE(1.0), IEEE754binary64LE(mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0xf0),mpt::as_byte(0x3f))); VERIFY_EQUAL(IEEE754binary64BE(1.0), IEEE754binary64BE(mpt::as_byte(0x3f),mpt::as_byte(0xf0),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00),mpt::as_byte(0x00))); // Packed integers with defined endianness { int8le le8; le8.set(-128); int8be be8; be8.set(-128); VERIFY_EQUAL(le8, -128); VERIFY_EQUAL(be8, -128); VERIFY_EQUAL(memcmp(&le8, "\x80", 1), 0); VERIFY_EQUAL(memcmp(&be8, "\x80", 1), 0); int16le le16; le16.set(0x1234); int16be be16; be16.set(0x1234); VERIFY_EQUAL(le16, 0x1234); VERIFY_EQUAL(be16, 0x1234); VERIFY_EQUAL(memcmp(&le16, "\x34\x12", 2), 0); VERIFY_EQUAL(memcmp(&be16, "\x12\x34", 2), 0); uint32le le32; le32.set(0xFFEEDDCCu); uint32be be32; be32.set(0xFFEEDDCCu); VERIFY_EQUAL(le32, 0xFFEEDDCCu); VERIFY_EQUAL(be32, 0xFFEEDDCCu); VERIFY_EQUAL(memcmp(&le32, "\xCC\xDD\xEE\xFF", 4), 0); VERIFY_EQUAL(memcmp(&be32, "\xFF\xEE\xDD\xCC", 4), 0); uint64le le64; le64.set(0xDEADC0DE15C0FFEEull); uint64be be64; be64.set(0xDEADC0DE15C0FFEEull); VERIFY_EQUAL(le64, 0xDEADC0DE15C0FFEEull); VERIFY_EQUAL(be64, 0xDEADC0DE15C0FFEEull); VERIFY_EQUAL(memcmp(&le64, "\xEE\xFF\xC0\x15\xDE\xC0\xAD\xDE", 8), 0); VERIFY_EQUAL(memcmp(&be64, "\xDE\xAD\xC0\xDE\x15\xC0\xFF\xEE", 8), 0); } VERIFY_EQUAL(ModCommand::IsPcNote(NOTE_MAX), false); VERIFY_EQUAL(ModCommand::IsPcNote(NOTE_PC), true); VERIFY_EQUAL(ModCommand::IsPcNote(NOTE_PCS), true); VERIFY_EQUAL(CModSpecifications::ExtensionToType(".mod"), MOD_TYPE_MOD); VERIFY_EQUAL(CModSpecifications::ExtensionToType("mod"), MOD_TYPE_MOD); VERIFY_EQUAL(CModSpecifications::ExtensionToType(".s3m"), MOD_TYPE_S3M); VERIFY_EQUAL(CModSpecifications::ExtensionToType("s3m"), MOD_TYPE_S3M); VERIFY_EQUAL(CModSpecifications::ExtensionToType(".xm"), MOD_TYPE_XM); VERIFY_EQUAL(CModSpecifications::ExtensionToType("xm"), MOD_TYPE_XM); VERIFY_EQUAL(CModSpecifications::ExtensionToType(".it"), MOD_TYPE_IT); VERIFY_EQUAL(CModSpecifications::ExtensionToType("it"), MOD_TYPE_IT); VERIFY_EQUAL(CModSpecifications::ExtensionToType(".itp"), MOD_TYPE_NONE); VERIFY_EQUAL(CModSpecifications::ExtensionToType("itp"), MOD_TYPE_NONE); VERIFY_EQUAL(CModSpecifications::ExtensionToType("mptm"), MOD_TYPE_MPT); VERIFY_EQUAL(CModSpecifications::ExtensionToType("invalidExtension"), MOD_TYPE_NONE); VERIFY_EQUAL(CModSpecifications::ExtensionToType("ita"), MOD_TYPE_NONE); VERIFY_EQUAL(CModSpecifications::ExtensionToType("s2m"), MOD_TYPE_NONE); VERIFY_EQUAL(CModSpecifications::ExtensionToType(""), MOD_TYPE_NONE); VERIFY_EQUAL( mpt::round(1.99), 2.0 ); VERIFY_EQUAL( mpt::round(1.5), 2.0 ); VERIFY_EQUAL( mpt::round(1.1), 1.0 ); VERIFY_EQUAL( mpt::round(-0.1), 0.0 ); VERIFY_EQUAL( mpt::round(-0.5), -1.0 ); VERIFY_EQUAL( mpt::round(-0.9), -1.0 ); VERIFY_EQUAL( mpt::round(-1.4), -1.0 ); VERIFY_EQUAL( mpt::round(-1.7), -2.0 ); VERIFY_EQUAL( mpt::saturate_round(int32_max + 0.1), int32_max ); VERIFY_EQUAL( mpt::saturate_round(int32_max - 0.4), int32_max ); VERIFY_EQUAL( mpt::saturate_round(int32_min + 0.1), int32_min ); VERIFY_EQUAL( mpt::saturate_round(int32_min - 0.1), int32_min ); VERIFY_EQUAL( mpt::saturate_round(uint32_max + 0.499), uint32_max ); VERIFY_EQUAL( mpt::saturate_round(110.1), 110 ); VERIFY_EQUAL( mpt::saturate_round(-110.1), -110 ); VERIFY_EQUAL(mpt::popcount(static_cast(int32(-1))), 32); VERIFY_EQUAL(mpt::popcount(0u), 0); VERIFY_EQUAL(mpt::popcount(1u), 1); VERIFY_EQUAL(mpt::popcount(2u), 1); VERIFY_EQUAL(mpt::popcount(3u), 2); VERIFY_EQUAL(mpt::has_single_bit(0u), false); VERIFY_EQUAL(mpt::has_single_bit(1u), true); VERIFY_EQUAL(mpt::has_single_bit(2u), true); VERIFY_EQUAL(mpt::has_single_bit(3u), false); VERIFY_EQUAL(mpt::has_single_bit(4u), true); VERIFY_EQUAL(mpt::has_single_bit(5u), false); VERIFY_EQUAL(mpt::has_single_bit(6u), false); VERIFY_EQUAL(mpt::has_single_bit(7u), false); VERIFY_EQUAL(mpt::has_single_bit(8u), true); VERIFY_EQUAL(mpt::has_single_bit(9u), false); VERIFY_EQUAL(mpt::has_single_bit(uint32(0x7fffffffu)), false); VERIFY_EQUAL(mpt::has_single_bit(uint32(0x80000000u)), true); VERIFY_EQUAL(mpt::has_single_bit(uint32(0x80000001u)), false); VERIFY_EQUAL(mpt::has_single_bit(uint32(0xfffffffeu)), false); VERIFY_EQUAL(mpt::has_single_bit(uint32(0xffffffffu)), false); VERIFY_EQUAL(mpt::bit_ceil(0u), 1u); VERIFY_EQUAL(mpt::bit_ceil(1u), 1u); VERIFY_EQUAL(mpt::bit_ceil(2u), 2u); VERIFY_EQUAL(mpt::bit_ceil(3u), 4u); VERIFY_EQUAL(mpt::bit_ceil(4u), 4u); VERIFY_EQUAL(mpt::bit_ceil(5u), 8u); VERIFY_EQUAL(mpt::bit_ceil(6u), 8u); VERIFY_EQUAL(mpt::bit_ceil(7u), 8u); VERIFY_EQUAL(mpt::bit_ceil(8u), 8u); VERIFY_EQUAL(mpt::bit_ceil(9u), 16u); VERIFY_EQUAL(mpt::bit_ceil(uint32(0x7fffffffu)), 0x80000000u); VERIFY_EQUAL(mpt::bit_ceil(uint32(0x80000000u)), 0x80000000u); //VERIFY_EQUAL(mpt::bit_ceil(uint32(0x80000001u)), 0u); //VERIFY_EQUAL(mpt::bit_ceil(uint32(0xfffffffeu)), 0u); //VERIFY_EQUAL(mpt::bit_ceil(uint32(0xffffffffu)), 0u); VERIFY_EQUAL(mpt::bit_floor(0u), 0u); VERIFY_EQUAL(mpt::bit_floor(1u), 1u); VERIFY_EQUAL(mpt::bit_floor(2u), 2u); VERIFY_EQUAL(mpt::bit_floor(3u), 2u); VERIFY_EQUAL(mpt::bit_floor(4u), 4u); VERIFY_EQUAL(mpt::bit_floor(5u), 4u); VERIFY_EQUAL(mpt::bit_floor(6u), 4u); VERIFY_EQUAL(mpt::bit_floor(7u), 4u); VERIFY_EQUAL(mpt::bit_floor(8u), 8u); VERIFY_EQUAL(mpt::bit_floor(9u), 8u); VERIFY_EQUAL(mpt::bit_floor(uint32(0x7fffffffu)), 0x40000000u); VERIFY_EQUAL(mpt::bit_floor(uint32(0x80000000u)), 0x80000000u); VERIFY_EQUAL(mpt::bit_floor(uint32(0x80000001u)), 0x80000000u); VERIFY_EQUAL(mpt::bit_floor(uint32(0xfffffffeu)), 0x80000000u); VERIFY_EQUAL(mpt::bit_floor(uint32(0xffffffffu)), 0x80000000u); VERIFY_EQUAL(mpt::bit_width(0u), 0u); VERIFY_EQUAL(mpt::bit_width(1u), 1u); VERIFY_EQUAL(mpt::bit_width(2u), 2u); VERIFY_EQUAL(mpt::bit_width(3u), 2u); VERIFY_EQUAL(mpt::bit_width(4u), 3u); VERIFY_EQUAL(mpt::bit_width(5u), 3u); VERIFY_EQUAL(mpt::bit_width(6u), 3u); VERIFY_EQUAL(mpt::bit_width(7u), 3u); VERIFY_EQUAL(mpt::bit_width(8u), 4u); VERIFY_EQUAL(mpt::bit_width(9u), 4u); VERIFY_EQUAL(mpt::bit_width(uint32(0x7fffffffu)), 31u); VERIFY_EQUAL(mpt::bit_width(uint32(0x80000000u)), 32u); VERIFY_EQUAL(mpt::bit_width(uint32(0x80000001u)), 32u); VERIFY_EQUAL(mpt::bit_width(uint32(0xfffffffeu)), 32u); VERIFY_EQUAL(mpt::bit_width(uint32(0xffffffffu)), 32u); // trivials VERIFY_EQUAL( mpt::saturate_cast(-1), -1 ); VERIFY_EQUAL( mpt::saturate_cast(0), 0 ); VERIFY_EQUAL( mpt::saturate_cast(1), 1 ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min()), std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max()), std::numeric_limits::max() ); // signed / unsigned VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min()), std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max()), std::numeric_limits::max() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min()), (int32)std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max()), std::numeric_limits::max() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min()), (int64)std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max()), std::numeric_limits::max() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min()), std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max()), std::numeric_limits::max() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min()), std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max()), (uint32)std::numeric_limits::max() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min()), std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max()), (uint64)std::numeric_limits::max() ); // overflow VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min() - 1), std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max() + 1), std::numeric_limits::max() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min() - int64(1)), std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max() + int64(1)), std::numeric_limits::max() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min() - 1), std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max() + 1), (uint16)std::numeric_limits::max() + 1 ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::min() - int64(1)), std::numeric_limits::min() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max() + int64(1)), (uint32)std::numeric_limits::max() + 1 ); VERIFY_EQUAL( mpt::saturate_cast( int16(32000) ), 127 ); VERIFY_EQUAL( mpt::saturate_cast( int16(-32000) ), -128 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(32000) ), 127 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(64000) ), 127 ); VERIFY_EQUAL( mpt::saturate_cast( int16(32000) ), 255 ); VERIFY_EQUAL( mpt::saturate_cast( int16(-32000) ), 0 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(32000) ), 255 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(64000) ), 255 ); VERIFY_EQUAL( mpt::saturate_cast( int16(32000) ), 32000 ); VERIFY_EQUAL( mpt::saturate_cast( int16(-32000) ), -32000 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(32000) ), 32000 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(64000) ), 32767 ); VERIFY_EQUAL( mpt::saturate_cast( int16(32000) ), 32000 ); VERIFY_EQUAL( mpt::saturate_cast( int16(-32000) ), 0 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(32000) ), 32000 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(64000) ), 64000 ); VERIFY_EQUAL( mpt::saturate_cast( int16(32000) ), 32000 ); VERIFY_EQUAL( mpt::saturate_cast( int16(-32000) ), -32000 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(32000) ), 32000 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(64000) ), 64000 ); VERIFY_EQUAL( mpt::saturate_cast( int16(32000) ), 32000 ); VERIFY_EQUAL( mpt::saturate_cast( int16(-32000) ), 0 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(32000) ), 32000 ); VERIFY_EQUAL( mpt::saturate_cast( uint16(64000) ), 64000 ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max() - 1), std::numeric_limits::max() ); VERIFY_EQUAL( mpt::saturate_cast(std::numeric_limits::max() - 1), std::numeric_limits::max() ); VERIFY_EQUAL( mpt::saturate_cast(static_cast(std::numeric_limits::max())), std::numeric_limits::max() ); VERIFY_EQUAL(mpt::rshift_signed(-32768, 1), mpt::rshift_signed_standard(-32768, 1)); VERIFY_EQUAL(mpt::rshift_signed(-32767, 1), mpt::rshift_signed_standard(-32767, 1)); VERIFY_EQUAL(mpt::rshift_signed(-32766, 1), mpt::rshift_signed_standard(-32766, 1)); VERIFY_EQUAL(mpt::rshift_signed( -2, 1), mpt::rshift_signed_standard( -2, 1)); VERIFY_EQUAL(mpt::rshift_signed( -1, 1), mpt::rshift_signed_standard( -1, 1)); VERIFY_EQUAL(mpt::rshift_signed( 0, 1), mpt::rshift_signed_standard( 0, 1)); VERIFY_EQUAL(mpt::rshift_signed( 1, 1), mpt::rshift_signed_standard( 1, 1)); VERIFY_EQUAL(mpt::rshift_signed( 2, 1), mpt::rshift_signed_standard( 2, 1)); VERIFY_EQUAL(mpt::rshift_signed( 32766, 1), mpt::rshift_signed_standard( 32766, 1)); VERIFY_EQUAL(mpt::rshift_signed( 32767, 1), mpt::rshift_signed_standard( 32767, 1)); VERIFY_EQUAL(mpt::rshift_signed(-32768, 14), mpt::rshift_signed_standard(-32768, 14)); VERIFY_EQUAL(mpt::rshift_signed(-32767, 14), mpt::rshift_signed_standard(-32767, 14)); VERIFY_EQUAL(mpt::rshift_signed(-32766, 14), mpt::rshift_signed_standard(-32766, 14)); VERIFY_EQUAL(mpt::rshift_signed( -2, 14), mpt::rshift_signed_standard( -2, 14)); VERIFY_EQUAL(mpt::rshift_signed( -1, 14), mpt::rshift_signed_standard( -1, 14)); VERIFY_EQUAL(mpt::rshift_signed( 0, 14), mpt::rshift_signed_standard( 0, 14)); VERIFY_EQUAL(mpt::rshift_signed( 1, 14), mpt::rshift_signed_standard( 1, 14)); VERIFY_EQUAL(mpt::rshift_signed( 2, 14), mpt::rshift_signed_standard( 2, 14)); VERIFY_EQUAL(mpt::rshift_signed( 32766, 14), mpt::rshift_signed_standard( 32766, 14)); VERIFY_EQUAL(mpt::rshift_signed( 32767, 14), mpt::rshift_signed_standard( 32767, 14)); VERIFY_EQUAL(mpt::rshift_signed(-32768, 15), mpt::rshift_signed_standard(-32768, 15)); VERIFY_EQUAL(mpt::rshift_signed(-32767, 15), mpt::rshift_signed_standard(-32767, 15)); VERIFY_EQUAL(mpt::rshift_signed(-32766, 15), mpt::rshift_signed_standard(-32766, 15)); VERIFY_EQUAL(mpt::rshift_signed( -2, 15), mpt::rshift_signed_standard( -2, 15)); VERIFY_EQUAL(mpt::rshift_signed( -1, 15), mpt::rshift_signed_standard( -1, 15)); VERIFY_EQUAL(mpt::rshift_signed( 0, 15), mpt::rshift_signed_standard( 0, 15)); VERIFY_EQUAL(mpt::rshift_signed( 1, 15), mpt::rshift_signed_standard( 1, 15)); VERIFY_EQUAL(mpt::rshift_signed( 2, 15), mpt::rshift_signed_standard( 2, 15)); VERIFY_EQUAL(mpt::rshift_signed( 32766, 15), mpt::rshift_signed_standard( 32766, 15)); VERIFY_EQUAL(mpt::rshift_signed( 32767, 15), mpt::rshift_signed_standard( 32767, 15)); VERIFY_EQUAL(mpt::lshift_signed(-32768, 1), mpt::lshift_signed_standard(-32768, 1)); VERIFY_EQUAL(mpt::lshift_signed(-32767, 1), mpt::lshift_signed_standard(-32767, 1)); VERIFY_EQUAL(mpt::lshift_signed(-32766, 1), mpt::lshift_signed_standard(-32766, 1)); VERIFY_EQUAL(mpt::lshift_signed( -2, 1), mpt::lshift_signed_standard( -2, 1)); VERIFY_EQUAL(mpt::lshift_signed( -1, 1), mpt::lshift_signed_standard( -1, 1)); VERIFY_EQUAL(mpt::lshift_signed( 0, 1), mpt::lshift_signed_standard( 0, 1)); VERIFY_EQUAL(mpt::lshift_signed( 1, 1), mpt::lshift_signed_standard( 1, 1)); VERIFY_EQUAL(mpt::lshift_signed( 2, 1), mpt::lshift_signed_standard( 2, 1)); VERIFY_EQUAL(mpt::lshift_signed( 32766, 1), mpt::lshift_signed_standard( 32766, 1)); VERIFY_EQUAL(mpt::lshift_signed( 32767, 1), mpt::lshift_signed_standard( 32767, 1)); VERIFY_EQUAL(mpt::lshift_signed(-32768, 14), mpt::lshift_signed_standard(-32768, 14)); VERIFY_EQUAL(mpt::lshift_signed(-32767, 14), mpt::lshift_signed_standard(-32767, 14)); VERIFY_EQUAL(mpt::lshift_signed(-32766, 14), mpt::lshift_signed_standard(-32766, 14)); VERIFY_EQUAL(mpt::lshift_signed( -2, 14), mpt::lshift_signed_standard( -2, 14)); VERIFY_EQUAL(mpt::lshift_signed( -1, 14), mpt::lshift_signed_standard( -1, 14)); VERIFY_EQUAL(mpt::lshift_signed( 0, 14), mpt::lshift_signed_standard( 0, 14)); VERIFY_EQUAL(mpt::lshift_signed( 1, 14), mpt::lshift_signed_standard( 1, 14)); VERIFY_EQUAL(mpt::lshift_signed( 2, 14), mpt::lshift_signed_standard( 2, 14)); VERIFY_EQUAL(mpt::lshift_signed( 32766, 14), mpt::lshift_signed_standard( 32766, 14)); VERIFY_EQUAL(mpt::lshift_signed( 32767, 14), mpt::lshift_signed_standard( 32767, 14)); VERIFY_EQUAL(mpt::lshift_signed(-32768, 15), mpt::lshift_signed_standard(-32768, 15)); VERIFY_EQUAL(mpt::lshift_signed(-32767, 15), mpt::lshift_signed_standard(-32767, 15)); VERIFY_EQUAL(mpt::lshift_signed(-32766, 15), mpt::lshift_signed_standard(-32766, 15)); VERIFY_EQUAL(mpt::lshift_signed( -2, 15), mpt::lshift_signed_standard( -2, 15)); VERIFY_EQUAL(mpt::lshift_signed( -1, 15), mpt::lshift_signed_standard( -1, 15)); VERIFY_EQUAL(mpt::lshift_signed( 0, 15), mpt::lshift_signed_standard( 0, 15)); VERIFY_EQUAL(mpt::lshift_signed( 1, 15), mpt::lshift_signed_standard( 1, 15)); VERIFY_EQUAL(mpt::lshift_signed( 2, 15), mpt::lshift_signed_standard( 2, 15)); VERIFY_EQUAL(mpt::lshift_signed( 32766, 15), mpt::lshift_signed_standard( 32766, 15)); VERIFY_EQUAL(mpt::lshift_signed( 32767, 15), mpt::lshift_signed_standard( 32767, 15)); #if MPT_COMPILER_SHIFT_SIGNED VERIFY_EQUAL(mpt::rshift_signed(-32768, 1), (-32768) >> 1); VERIFY_EQUAL(mpt::rshift_signed(-32767, 1), (-32767) >> 1); VERIFY_EQUAL(mpt::rshift_signed(-32766, 1), (-32766) >> 1); VERIFY_EQUAL(mpt::rshift_signed( -2, 1), ( -2) >> 1); VERIFY_EQUAL(mpt::rshift_signed( -1, 1), ( -1) >> 1); VERIFY_EQUAL(mpt::rshift_signed( 0, 1), ( 0) >> 1); VERIFY_EQUAL(mpt::rshift_signed( 1, 1), ( 1) >> 1); VERIFY_EQUAL(mpt::rshift_signed( 2, 1), ( 2) >> 1); VERIFY_EQUAL(mpt::rshift_signed( 32766, 1), ( 32766) >> 1); VERIFY_EQUAL(mpt::rshift_signed( 32767, 1), ( 32767) >> 1); VERIFY_EQUAL(mpt::rshift_signed(-32768, 14), (-32768) >> 14); VERIFY_EQUAL(mpt::rshift_signed(-32767, 14), (-32767) >> 14); VERIFY_EQUAL(mpt::rshift_signed(-32766, 14), (-32766) >> 14); VERIFY_EQUAL(mpt::rshift_signed( -2, 14), ( -2) >> 14); VERIFY_EQUAL(mpt::rshift_signed( -1, 14), ( -1) >> 14); VERIFY_EQUAL(mpt::rshift_signed( 0, 14), ( 0) >> 14); VERIFY_EQUAL(mpt::rshift_signed( 1, 14), ( 1) >> 14); VERIFY_EQUAL(mpt::rshift_signed( 2, 14), ( 2) >> 14); VERIFY_EQUAL(mpt::rshift_signed( 32766, 14), ( 32766) >> 14); VERIFY_EQUAL(mpt::rshift_signed( 32767, 14), ( 32767) >> 14); VERIFY_EQUAL(mpt::rshift_signed(-32768, 15), (-32768) >> 15); VERIFY_EQUAL(mpt::rshift_signed(-32767, 15), (-32767) >> 15); VERIFY_EQUAL(mpt::rshift_signed(-32766, 15), (-32766) >> 15); VERIFY_EQUAL(mpt::rshift_signed( -2, 15), ( -2) >> 15); VERIFY_EQUAL(mpt::rshift_signed( -1, 15), ( -1) >> 15); VERIFY_EQUAL(mpt::rshift_signed( 0, 15), ( 0) >> 15); VERIFY_EQUAL(mpt::rshift_signed( 1, 15), ( 1) >> 15); VERIFY_EQUAL(mpt::rshift_signed( 2, 15), ( 2) >> 15); VERIFY_EQUAL(mpt::rshift_signed( 32766, 15), ( 32766) >> 15); VERIFY_EQUAL(mpt::rshift_signed( 32767, 15), ( 32767) >> 15); VERIFY_EQUAL(mpt::lshift_signed(-32768, 1), (-32768) << 1); VERIFY_EQUAL(mpt::lshift_signed(-32767, 1), (-32767) << 1); VERIFY_EQUAL(mpt::lshift_signed(-32766, 1), (-32766) << 1); VERIFY_EQUAL(mpt::lshift_signed( -2, 1), ( -2) << 1); VERIFY_EQUAL(mpt::lshift_signed( -1, 1), ( -1) << 1); VERIFY_EQUAL(mpt::lshift_signed( 0, 1), ( 0) << 1); VERIFY_EQUAL(mpt::lshift_signed( 1, 1), ( 1) << 1); VERIFY_EQUAL(mpt::lshift_signed( 2, 1), ( 2) << 1); VERIFY_EQUAL(mpt::lshift_signed( 32766, 1), ( 32766) << 1); VERIFY_EQUAL(mpt::lshift_signed( 32767, 1), ( 32767) << 1); VERIFY_EQUAL(mpt::lshift_signed(-32768, 14), (-32768) << 14); VERIFY_EQUAL(mpt::lshift_signed(-32767, 14), (-32767) << 14); VERIFY_EQUAL(mpt::lshift_signed(-32766, 14), (-32766) << 14); VERIFY_EQUAL(mpt::lshift_signed( -2, 14), ( -2) << 14); VERIFY_EQUAL(mpt::lshift_signed( -1, 14), ( -1) << 14); VERIFY_EQUAL(mpt::lshift_signed( 0, 14), ( 0) << 14); VERIFY_EQUAL(mpt::lshift_signed( 1, 14), ( 1) << 14); VERIFY_EQUAL(mpt::lshift_signed( 2, 14), ( 2) << 14); VERIFY_EQUAL(mpt::lshift_signed( 32766, 14), ( 32766) << 14); VERIFY_EQUAL(mpt::lshift_signed( 32767, 14), ( 32767) << 14); VERIFY_EQUAL(mpt::lshift_signed(-32768, 15), (-32768) << 15); VERIFY_EQUAL(mpt::lshift_signed(-32767, 15), (-32767) << 15); VERIFY_EQUAL(mpt::lshift_signed(-32766, 15), (-32766) << 15); VERIFY_EQUAL(mpt::lshift_signed( -2, 15), ( -2) << 15); VERIFY_EQUAL(mpt::lshift_signed( -1, 15), ( -1) << 15); VERIFY_EQUAL(mpt::lshift_signed( 0, 15), ( 0) << 15); VERIFY_EQUAL(mpt::lshift_signed( 1, 15), ( 1) << 15); VERIFY_EQUAL(mpt::lshift_signed( 2, 15), ( 2) << 15); VERIFY_EQUAL(mpt::lshift_signed( 32766, 15), ( 32766) << 15); VERIFY_EQUAL(mpt::lshift_signed