771 lines
17 KiB
C++
771 lines
17 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: tests/benchmarks/strings.cpp
|
|
// Purpose: String-related benchmarks
|
|
// Author: Vadim Zeitlin
|
|
// Created: 2008-07-19
|
|
// Copyright: (c) 2008 Vadim Zeitlin <vadim@wxwidgets.org>
|
|
// Licence: wxWindows licence
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "wx/string.h"
|
|
#include "wx/ffile.h"
|
|
#include "wx/arrstr.h"
|
|
|
|
#include "bench.h"
|
|
#include "htmlparser/htmlpars.h"
|
|
|
|
static const char asciistr[] =
|
|
"This is just the first line of a very long 7 bit ASCII string"
|
|
"This is just the second line of a very long 7 bit ASCII string"
|
|
"This is just the third line of a very long 7 bit ASCII string"
|
|
"This is just the fourth line of a very long 7 bit ASCII string"
|
|
"This is just the fifth line of a very long 7 bit ASCII string"
|
|
"This is just the sixth line of a very long 7 bit ASCII string"
|
|
"This is just the seventh line of a very long 7 bit ASCII string"
|
|
"This is just the eighth line of a very long 7 bit ASCII string"
|
|
"This is just the ninth line of a very long 7 bit ASCII string"
|
|
"This is just the tenth line of a very long 7 bit ASCII string"
|
|
;
|
|
|
|
static const char utf8str[] =
|
|
"\xD0\xA6\xD0\xB5\xD0\xBB\xD0\xBE\xD0\xB5 \xD1\x87\xD0\xB8\xD1\x81\xD0\xBB\xD0\xBE 0"
|
|
"\xD0\xA6\xD0\xB5\xD0\xBB\xD0\xBE\xD0\xB5 \xD1\x87\xD0\xB8\xD1\x81\xD0\xBB\xD0\xBE 1"
|
|
"\xD0\xA6\xD0\xB5\xD0\xBB\xD0\xBE\xD0\xB5 \xD1\x87\xD0\xB8\xD1\x81\xD0\xBB\xD0\xBE 2"
|
|
"\xD0\xA6\xD0\xB5\xD0\xBB\xD0\xBE\xD0\xB5 \xD1\x87\xD0\xB8\xD1\x81\xD0\xBB\xD0\xBE 3"
|
|
"\xD0\xA6\xD0\xB5\xD0\xBB\xD0\xBE\xD0\xB5 \xD1\x87\xD0\xB8\xD1\x81\xD0\xBB\xD0\xBE 4"
|
|
"\xD0\xA6\xD0\xB5\xD0\xBB\xD0\xBE\xD0\xB5 \xD1\x87\xD0\xB8\xD1\x81\xD0\xBB\xD0\xBE 5"
|
|
"\xD0\xA6\xD0\xB5\xD0\xBB\xD0\xBE\xD0\xB5 \xD1\x87\xD0\xB8\xD1\x81\xD0\xBB\xD0\xBE 6"
|
|
"\xD0\xA6\xD0\xB5\xD0\xBB\xD0\xBE\xD0\xB5 \xD1\x87\xD0\xB8\xD1\x81\xD0\xBB\xD0\xBE 7"
|
|
"\xD0\xA6\xD0\xB5\xD0\xBB\xD0\xBE\xD0\xB5 \xD1\x87\xD0\xB8\xD1\x81\xD0\xBB\xD0\xBE 8"
|
|
"\xD0\xA6\xD0\xB5\xD0\xBB\xD0\xBE\xD0\xB5 \xD1\x87\xD0\xB8\xD1\x81\xD0\xBB\xD0\xBE 9"
|
|
;
|
|
|
|
namespace
|
|
{
|
|
|
|
const wxString& GetTestAsciiString()
|
|
{
|
|
static wxString testString;
|
|
if ( testString.empty() )
|
|
{
|
|
long num = Bench::GetNumericParameter();
|
|
if ( !num )
|
|
num = 1;
|
|
|
|
for ( long n = 0; n < num; n++ )
|
|
testString += wxString::FromAscii(asciistr);
|
|
}
|
|
|
|
return testString;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
// this is just a baseline
|
|
BENCHMARK_FUNC(Strlen)
|
|
{
|
|
if ( strlen(utf8str) != WXSIZEOF(utf8str) - 1 )
|
|
return false;
|
|
|
|
if ( strlen(asciistr) != WXSIZEOF(asciistr) - 1 )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// FromUTF8() benchmarks
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BENCHMARK_FUNC(FromUTF8)
|
|
{
|
|
wxString s = wxString::FromUTF8(utf8str);
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
s = wxString::FromUTF8(asciistr);
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(FromUTF8WithNpos)
|
|
{
|
|
wxString s = wxString::FromUTF8(utf8str, wxString::npos);
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
s = wxString::FromUTF8(asciistr, wxString::npos);
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(FromUTF8WithLen)
|
|
{
|
|
wxString s = wxString::FromUTF8(utf8str, WXSIZEOF(utf8str));
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
s = wxString::FromUTF8(asciistr, WXSIZEOF(asciistr));
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// FromUTF8Unchecked() benchmarks
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BENCHMARK_FUNC(FromUTF8Unchecked)
|
|
{
|
|
wxString s = wxString::FromUTF8Unchecked(utf8str);
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
s = wxString::FromUTF8Unchecked(asciistr);
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(FromUTF8UncheckedWithNpos)
|
|
{
|
|
wxString s = wxString::FromUTF8Unchecked(utf8str, wxString::npos);
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
s = wxString::FromUTF8Unchecked(asciistr, wxString::npos);
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(FromUTF8UncheckedWithLen)
|
|
{
|
|
wxString s = wxString::FromUTF8Unchecked(utf8str, WXSIZEOF(utf8str));
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
s = wxString::FromUTF8Unchecked(asciistr, WXSIZEOF(asciistr));
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// FromAscii() benchmarks
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BENCHMARK_FUNC(FromAscii)
|
|
{
|
|
wxString s = wxString::FromAscii(asciistr);
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(FromAsciiWithNpos)
|
|
{
|
|
wxString s = wxString::FromAscii(asciistr);
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(FromAsciiWithLen)
|
|
{
|
|
wxString s = wxString::FromAscii(asciistr, WXSIZEOF(asciistr));
|
|
if ( s.empty() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// simple string iteration
|
|
// ----------------------------------------------------------------------------
|
|
|
|
// baseline
|
|
BENCHMARK_FUNC(ForCString)
|
|
{
|
|
for ( size_t n = 0; n < WXSIZEOF(asciistr); n++ )
|
|
{
|
|
if ( asciistr[n] == '~' )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(ForStringIndex)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
const size_t len = s.length();
|
|
for ( size_t n = 0; n < len; n++ )
|
|
{
|
|
if ( s[n] == '~' )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(ForStringIter)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
const wxString::const_iterator end = s.end();
|
|
for ( wxString::const_iterator i = s.begin(); i != end; ++i )
|
|
{
|
|
if ( *i == '~' )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(ForStringRIter)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
const wxString::const_reverse_iterator rend = s.rend();
|
|
for ( wxString::const_reverse_iterator i = s.rbegin(); i != rend; ++i )
|
|
{
|
|
if ( *i == '~' )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxString::Replace()
|
|
// ----------------------------------------------------------------------------
|
|
|
|
const size_t ASCIISTR_LEN = strlen(asciistr);
|
|
|
|
BENCHMARK_FUNC(ReplaceLoop)
|
|
{
|
|
wxString str('x', ASCIISTR_LEN);
|
|
for ( size_t n = 0; n < ASCIISTR_LEN; n++ )
|
|
{
|
|
if ( str[n] == 'a' )
|
|
str[n] = 'z';
|
|
}
|
|
|
|
return str.length() != 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(ReplaceNone)
|
|
{
|
|
wxString str('x', ASCIISTR_LEN);
|
|
return str.Replace("a", "z") == 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(ReplaceSome)
|
|
{
|
|
wxString str(asciistr);
|
|
return str.Replace("7", "8") != 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(ReplaceAll)
|
|
{
|
|
wxString str('x', ASCIISTR_LEN);
|
|
return str.Replace("x", "y") != 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(ReplaceLonger)
|
|
{
|
|
wxString str('x', ASCIISTR_LEN);
|
|
return str.Replace("x", "yy") != 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(ReplaceShorter)
|
|
{
|
|
wxString str('x', ASCIISTR_LEN);
|
|
return str.Replace("xx", "y") != 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// string arrays
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BENCHMARK_FUNC(ArrStrPushBack)
|
|
{
|
|
wxArrayString a;
|
|
for (int i = 0; i < 100; ++i)
|
|
{
|
|
a.push_back(wxString(asciistr));
|
|
a.push_back(wxString(utf8str));
|
|
}
|
|
return !a.empty();
|
|
}
|
|
|
|
BENCHMARK_FUNC(ArrStrInsert)
|
|
{
|
|
wxArrayString a;
|
|
for (int i = 0; i < 100; ++i)
|
|
{
|
|
a.insert(a.begin(), wxString(asciistr));
|
|
a.insert(a.begin(), wxString(utf8str));
|
|
}
|
|
return !a.empty();
|
|
}
|
|
|
|
BENCHMARK_FUNC(ArrStrSort)
|
|
{
|
|
wxArrayString a;
|
|
a.reserve(100);
|
|
for (int i = 0; i < 100; ++i)
|
|
a.push_back(wxString(asciistr + i));
|
|
a.Sort();
|
|
return !a.empty();
|
|
}
|
|
|
|
BENCHMARK_FUNC(VectorStrPushBack)
|
|
{
|
|
std::vector<wxString> v;
|
|
for (int i = 0; i < 100; ++i)
|
|
{
|
|
v.push_back(wxString(asciistr));
|
|
v.push_back(wxString(utf8str));
|
|
}
|
|
return !v.empty();
|
|
}
|
|
|
|
BENCHMARK_FUNC(VectorStrInsert)
|
|
{
|
|
std::vector<wxString> v;
|
|
for (int i = 0; i < 100; ++i)
|
|
{
|
|
v.insert(v.begin(), wxString(asciistr));
|
|
v.insert(v.begin(), wxString(utf8str));
|
|
}
|
|
return !v.empty();
|
|
}
|
|
|
|
BENCHMARK_FUNC(VectorStrSort)
|
|
{
|
|
std::vector<wxString> v;
|
|
v.reserve(100);
|
|
for (int i = 0; i < 100; ++i)
|
|
v.push_back(wxString(asciistr + i));
|
|
std::sort(v.begin(), v.end());
|
|
return !v.empty();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// string case conversion
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BENCHMARK_FUNC(Lower)
|
|
{
|
|
return GetTestAsciiString().Lower().length() > 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(Upper)
|
|
{
|
|
return GetTestAsciiString().Upper().length() > 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// string comparison
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BENCHMARK_FUNC(StrcmpA)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
|
|
return wxCRT_StrcmpA(s.c_str(), s.c_str()) == 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(StrcmpW)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
|
|
return wxCRT_StrcmpW(s.wc_str(), s.wc_str()) == 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(StricmpA)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
|
|
return wxCRT_StricmpA(s.c_str(), s.c_str()) == 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(StricmpW)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
|
|
return wxCRT_StricmpW(s.wc_str(), s.wc_str()) == 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(StringCmp)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
|
|
return s.Cmp(s) == 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(StringCmpNoCase)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
|
|
return s.CmpNoCase(s) == 0;
|
|
}
|
|
|
|
// Also benchmark various native functions under MSW. Surprisingly/annoyingly
|
|
// they sometimes have vastly better performance than alternatives, especially
|
|
// for case-sensitive comparison (see #10375).
|
|
#ifdef __WINDOWS__
|
|
|
|
#include "wx/msw/wrapwin.h"
|
|
|
|
BENCHMARK_FUNC(MSWlstrcmp)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
|
|
return lstrcmp(s.t_str(), s.t_str()) == 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(MSWlstrcmpi)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
|
|
return lstrcmpi(s.t_str(), s.t_str()) == 0;
|
|
}
|
|
|
|
BENCHMARK_FUNC(MSWCompareString)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
|
|
return ::CompareString
|
|
(
|
|
LOCALE_USER_DEFAULT,
|
|
0,
|
|
s.t_str(), s.length(),
|
|
s.t_str(), s.length()
|
|
) == CSTR_EQUAL;
|
|
}
|
|
|
|
BENCHMARK_FUNC(MSWCompareStringIgnoreCase)
|
|
{
|
|
const wxString& s = GetTestAsciiString();
|
|
|
|
return ::CompareString
|
|
(
|
|
LOCALE_USER_DEFAULT,
|
|
NORM_IGNORECASE,
|
|
s.t_str(), s.length(),
|
|
s.t_str(), s.length()
|
|
) == CSTR_EQUAL;
|
|
}
|
|
|
|
#endif // __WINDOWS__
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// string buffers: wx[W]CharBuffer
|
|
// ----------------------------------------------------------------------------
|
|
|
|
BENCHMARK_FUNC(CharBuffer)
|
|
{
|
|
wxString str(asciistr);
|
|
|
|
// NB: wxStrlen() is here to simulate some use of the returned buffer.
|
|
// Both mb_str() and wc_str() are used so that this code does something
|
|
// nontrivial in any build.
|
|
return wxStrlen(str.mb_str()) == ASCIISTR_LEN &&
|
|
wxStrlen(str.wc_str()) == ASCIISTR_LEN;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// wxString::operator[] - parse large HTML page
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class DummyParser : public wx28HtmlParser
|
|
{
|
|
public:
|
|
virtual wxObject* GetProduct() { return nullptr; }
|
|
virtual void AddText(const wxChar*) {}
|
|
};
|
|
|
|
|
|
BENCHMARK_FUNC(ParseHTML)
|
|
{
|
|
// static so that construction time is not counted
|
|
static DummyParser parser;
|
|
static wxString html;
|
|
if ( html.empty() )
|
|
{
|
|
wxString html1;
|
|
wxFFile("htmltest.html").ReadAll(&html1, wxConvUTF8);
|
|
|
|
// this is going to make for some invalid HTML, of course, but it
|
|
// doesn't really matter
|
|
long num = Bench::GetNumericParameter();
|
|
if ( !num )
|
|
num = 1;
|
|
|
|
for ( long n = 0; n < num; n++ )
|
|
html += html1;
|
|
}
|
|
|
|
parser.Parse(html);
|
|
|
|
return true;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// conversions between strings and numbers
|
|
// ----------------------------------------------------------------------------
|
|
|
|
namespace
|
|
{
|
|
|
|
const struct ToDoubleData
|
|
{
|
|
const char *str;
|
|
double value;
|
|
bool ok;
|
|
} toDoubleData[] =
|
|
{
|
|
{ "1", 1, true },
|
|
{ "1.23", 1.23, true },
|
|
{ ".1", .1, true },
|
|
{ "1.", 1, true },
|
|
{ "1..", 0, false },
|
|
{ "0", 0, true },
|
|
{ "a", 0, false },
|
|
{ "12345", 12345, true },
|
|
{ "-1", -1, true },
|
|
{ "--1", 0, false },
|
|
{ "-3E-5", -3E-5, true },
|
|
{ "-3E-abcde5", 0, false },
|
|
};
|
|
|
|
const struct FromDoubleData
|
|
{
|
|
double value;
|
|
int prec;
|
|
const char *str;
|
|
} fromDoubleData[] =
|
|
{
|
|
{ 1.23, -1, "1.23" },
|
|
{ -0.45678, -1, "-0.45678" },
|
|
{ 1.2345678, 0, "1" },
|
|
{ 1.2345678, 1, "1.2" },
|
|
{ 1.2345678, 2, "1.23" },
|
|
{ 1.2345678, 3, "1.235" },
|
|
};
|
|
|
|
} // anonymous namespace
|
|
|
|
BENCHMARK_FUNC(StringToDouble)
|
|
{
|
|
double d = 0.;
|
|
for ( const auto& data : toDoubleData )
|
|
{
|
|
if ( wxString(data.str).ToDouble(&d) != data.ok )
|
|
return false;
|
|
|
|
if ( data.ok && d != data.value )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(StringToCDouble)
|
|
{
|
|
double d = 0.;
|
|
for ( const auto& data : toDoubleData )
|
|
{
|
|
if ( wxString(data.str).ToCDouble(&d) != data.ok )
|
|
return false;
|
|
|
|
if ( data.ok && d != data.value )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(StringFromDouble)
|
|
{
|
|
for ( const auto& data : fromDoubleData )
|
|
{
|
|
const wxString& s = wxString::FromDouble(data.value, data.prec);
|
|
if ( wxStrcmp(s.utf8_str(), data.str) != 0 )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(StringFromCDouble)
|
|
{
|
|
for ( const auto& data : fromDoubleData )
|
|
{
|
|
const wxString& s = wxString::FromCDouble(data.value, data.prec);
|
|
if ( wxStrcmp(s.utf8_str(), data.str) != 0 )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(Strtod)
|
|
{
|
|
double d = 0.;
|
|
char* end = nullptr;
|
|
for ( const auto& data : toDoubleData )
|
|
{
|
|
d = strtod(data.str, &end);
|
|
|
|
if ( (end && *end == '\0') != data.ok )
|
|
return false;
|
|
|
|
if ( data.ok && d != data.value )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(PrintfDouble)
|
|
{
|
|
char buf[64];
|
|
for ( const auto& data : fromDoubleData )
|
|
{
|
|
if ( data.prec == -1 )
|
|
{
|
|
if ( !snprintf(buf, sizeof(buf), "%g", data.value) )
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if ( !snprintf(buf, sizeof(buf), "%.*f", data.prec, data.value) )
|
|
return false;
|
|
}
|
|
|
|
if ( strcmp(buf, data.str) != 0 )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(AppendString)
|
|
{
|
|
static wxString s;
|
|
long num = Bench::GetNumericParameter();
|
|
if ( !num )
|
|
num = 1;
|
|
|
|
s.clear();
|
|
for ( int n = 0; n < num; n++ )
|
|
{
|
|
s << wxS("123");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(AppendIntDirect)
|
|
{
|
|
static wxString s;
|
|
long num = Bench::GetNumericParameter();
|
|
if ( !num )
|
|
num = 1;
|
|
|
|
s.clear();
|
|
for ( int n = 0; n < num; n++ )
|
|
{
|
|
s << n;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(AppendIntViaString)
|
|
{
|
|
static wxString s;
|
|
long num = Bench::GetNumericParameter();
|
|
if ( !num )
|
|
num = 1;
|
|
|
|
s.clear();
|
|
for ( int n = 0; n < num; n++ )
|
|
{
|
|
#if wxUSE_UNICODE_WCHAR
|
|
s << std::to_wstring(n);
|
|
#else
|
|
s << std::to_string(n);
|
|
#endif
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#if wxHAS_CXX17_INCLUDE(<charconv>)
|
|
|
|
#include <charconv>
|
|
|
|
#ifdef __cpp_lib_to_chars
|
|
BENCHMARK_FUNC(StdFromChars)
|
|
{
|
|
double d = 0.;
|
|
for ( const auto& data : toDoubleData )
|
|
{
|
|
const auto end = data.str + strlen(data.str);
|
|
const auto res = std::from_chars(data.str, end, d);
|
|
|
|
if ( (res.ptr == end && res.ec == std::errc{}) != data.ok )
|
|
return false;
|
|
|
|
if ( data.ok && d != data.value )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
BENCHMARK_FUNC(StdToChars)
|
|
{
|
|
char buf[64];
|
|
std::to_chars_result res;
|
|
for ( const auto& data : fromDoubleData )
|
|
{
|
|
if ( data.prec == -1 )
|
|
{
|
|
res = std::to_chars(buf, buf + sizeof(buf), data.value);
|
|
}
|
|
else
|
|
{
|
|
res = std::to_chars(buf, buf + sizeof(buf), data.value,
|
|
std::chars_format::fixed, data.prec);
|
|
}
|
|
|
|
if ( res.ec != std::errc{} )
|
|
return false;
|
|
|
|
*res.ptr = '\0';
|
|
|
|
if ( strcmp(buf, data.str) != 0 )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endif // __cpp_lib_to_chars
|
|
|
|
#endif // wxHAS_CXX17_INCLUDE(<charconv>)
|