initial commit

Signed-off-by: Peter Siegmund <mars3142@noreply.mars3142.dev>

libs/wxWidgets-3.3.1/tests/benchmarks/strings.cpp

@@ -0,0 +1,770 @@
+/////////////////////////////////////////////////////////////////////////////
+// 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>)