Changeset 181845 in webkit


Ignore:
Timestamp:
Mar 22, 2015 10:04:46 PM (9 years ago)
Author:
benjamin@webkit.org
Message:

CSS Selectors: fix attribute case-insensitive matching of Contain and List
​https://bugs.webkit.org/show_bug.cgi?id=142932

Reviewed by Darin Adler.

Source/WebCore:

Fix the last two attribute selectors that were using full case-insensitive
match:

-Contain ([foo*=bar]).
-List (foo~=bar]).

Tests: fast/selectors/attribute-contains-value-matching-is-ascii-case-insensitive.html

fast/selectors/attribute-list-value-matching-is-ascii-case-insensitive.html

  • css/SelectorChecker.cpp:

(WebCore::attributeValueMatches):

  • cssjit/SelectorCompiler.cpp:

(WebCore::SelectorCompiler::attributeValueContains):
(WebCore::SelectorCompiler::attributeValueSpaceSeparetedListContains):

Source/WTF:

Add some utility functions to the string classes to find substrings
using ASCII case-insensitive comparisons.

  • wtf/text/AtomicString.h:

(WTF::AtomicString::contains):
Add the light version that only lock one register.

(WTF::AtomicString::containsIgnoringASCIICase):
(WTF::AtomicString::findIgnoringASCIICase):

  • wtf/text/StringCommon.h:

(WTF::findIgnoringASCIICase):
This is the common implementation used by StringView and StringImpl.

  • wtf/text/StringImpl.cpp:

(WTF::StringImpl::findIgnoringASCIICase):

  • wtf/text/StringImpl.h:
  • wtf/text/StringView.cpp:

(WTF::StringView::containsIgnoringASCIICase):
(WTF::StringView::findIgnoringASCIICase):

  • wtf/text/StringView.h:
  • wtf/text/WTFString.h:

(WTF::String::findIgnoringASCIICase):
(WTF::String::contains):
(WTF::String::containsIgnoringASCIICase):

Tools:

Add tests for the new features and fix some existing tests using the
stringFromUTF8() utility recently added by Dhi.

  • TestWebKitAPI/Tests/WTF/StringImpl.cpp:

(TestWebKitAPI::stringFromUTF8):

  • TestWebKitAPI/Tests/WTF/StringView.cpp:

LayoutTests:

  • fast/selectors/attribute-contains-value-matching-is-ascii-case-insensitive-expected.txt: Added.
  • fast/selectors/attribute-contains-value-matching-is-ascii-case-insensitive.html: Added.
  • fast/selectors/attribute-list-value-matching-is-ascii-case-insensitive-expected.txt: Added.
  • fast/selectors/attribute-list-value-matching-is-ascii-case-insensitive.html: Added.
Location:
trunk
Files:
4 added
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r181842 r181845  
     12015-03-22  Benjamin Poulain  <benjamin@webkit.org>
     2
     3        CSS Selectors: fix attribute case-insensitive matching of Contain and List
     4        https://bugs.webkit.org/show_bug.cgi?id=142932
     5
     6        Reviewed by Darin Adler.
     7
     8        * fast/selectors/attribute-contains-value-matching-is-ascii-case-insensitive-expected.txt: Added.
     9        * fast/selectors/attribute-contains-value-matching-is-ascii-case-insensitive.html: Added.
     10        * fast/selectors/attribute-list-value-matching-is-ascii-case-insensitive-expected.txt: Added.
     11        * fast/selectors/attribute-list-value-matching-is-ascii-case-insensitive.html: Added.
     12
    1132015-03-22  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
    214

  • trunk/Source/WTF/ChangeLog

    r181758 r181845  
     12015-03-22  Benjamin Poulain  <benjamin@webkit.org>
     2
     3        CSS Selectors: fix attribute case-insensitive matching of Contain and List
     4        https://bugs.webkit.org/show_bug.cgi?id=142932
     5
     6        Reviewed by Darin Adler.
     7
     8        Add some utility functions to the string classes to find substrings
     9        using ASCII case-insensitive comparisons.
     10
     11        * wtf/text/AtomicString.h:
     12        (WTF::AtomicString::contains):
     13        Add the light version that only lock one register.
     14
     15        (WTF::AtomicString::containsIgnoringASCIICase):
     16        (WTF::AtomicString::findIgnoringASCIICase):
     17
     18        * wtf/text/StringCommon.h:
     19        (WTF::findIgnoringASCIICase):
     20        This is the common implementation used by StringView and StringImpl.
     21
     22        * wtf/text/StringImpl.cpp:
     23        (WTF::StringImpl::findIgnoringASCIICase):
     24        * wtf/text/StringImpl.h:
     25        * wtf/text/StringView.cpp:
     26        (WTF::StringView::containsIgnoringASCIICase):
     27        (WTF::StringView::findIgnoringASCIICase):
     28        * wtf/text/StringView.h:
     29        * wtf/text/WTFString.h:
     30        (WTF::String::findIgnoringASCIICase):
     31        (WTF::String::contains):
     32        (WTF::String::containsIgnoringASCIICase):
     33
    1342015-03-19  Andreas Kling  <akling@apple.com>
    235

  • trunk/Source/WTF/wtf/text/AtomicString.h

    r181525 r181845  
    116116    bool contains(const LChar* s, bool caseSensitive = true) const
    117117        { return m_string.contains(s, caseSensitive); }
    118     bool contains(const String& s, bool caseSensitive = true) const
     118    bool contains(const String& s) const
     119        { return m_string.contains(s); }
     120    bool contains(const String& s, bool caseSensitive) const
    119121        { return m_string.contains(s, caseSensitive); }
     122    bool containsIgnoringASCIICase(const String& s) const
     123        { return m_string.containsIgnoringASCIICase(s); }
    120124
    121125    size_t find(UChar c, unsigned start = 0) const { return m_string.find(c, start); }
    … …  
    124128    size_t find(const String& s, unsigned start = 0, bool caseSentitive = true) const
    125129        { return m_string.find(s, start, caseSentitive); }
     130    size_t findIgnoringASCIICase(const String& s) const
     131        { return m_string.findIgnoringASCIICase(s); }
     132    size_t findIgnoringASCIICase(const String& s, unsigned startOffset) const
     133        { return m_string.findIgnoringASCIICase(s, startOffset); }
    126134    size_t find(CharacterMatchFunctionPtr matchFunction, unsigned start = 0) const
    127135        { return m_string.find(matchFunction, start); }

  • trunk/Source/WTF/wtf/text/StringCommon.h

    r181525 r181845  
    418418}
    419419
     420template <typename SearchCharacterType, typename MatchCharacterType>
     421size_t findIgnoringASCIICase(const SearchCharacterType* source, const MatchCharacterType* matchCharacters, unsigned startOffset, unsigned searchLength, unsigned matchLength)
     422{
     423    ASSERT(searchLength >= matchLength);
     424
     425    const SearchCharacterType* startSearchedCharacters = source + startOffset;
     426
     427    // delta is the number of additional times to test; delta == 0 means test only once.
     428    unsigned delta = searchLength - matchLength;
     429
     430    for (unsigned i = 0; i <= delta; ++i) {
     431        if (equalIgnoringASCIICase(startSearchedCharacters + i, matchCharacters, matchLength))
     432            return startOffset + i;
     433    }
     434    return notFound;
     435}
     436
     437template<typename StringClassA, typename StringClassB>
     438size_t findIgnoringASCIICase(const StringClassA& source, const StringClassB& stringToFind, unsigned startOffset)
     439{
     440    unsigned sourceStringLength = source.length();
     441    unsigned matchLength = stringToFind.length();
     442    if (!matchLength)
     443        return std::min(startOffset, sourceStringLength);
     444
     445    // Check startOffset & matchLength are in range.
     446    if (startOffset > sourceStringLength)
     447        return notFound;
     448    unsigned searchLength = sourceStringLength - startOffset;
     449    if (matchLength > searchLength)
     450        return notFound;
     451
     452    if (source.is8Bit()) {
     453        if (stringToFind.is8Bit())
     454            return findIgnoringASCIICase(source.characters8(), stringToFind.characters8(), startOffset, searchLength, matchLength);
     455        return findIgnoringASCIICase(source.characters8(), stringToFind.characters16(), startOffset, searchLength, matchLength);
     456    }
     457
     458    if (stringToFind.is8Bit())
     459        return findIgnoringASCIICase(source.characters16(), stringToFind.characters8(), startOffset, searchLength, matchLength);
     460
     461    return findIgnoringASCIICase(source.characters16(), stringToFind.characters16(), startOffset, searchLength, matchLength);
     462}
     463
    420464}
    421465

  • trunk/Source/WTF/wtf/text/StringImpl.cpp

    r181525 r181845  
    12251225
    12261226    return findIgnoringCaseInner(characters16() + index, matchString->characters16(), index, searchLength, matchLength);
     1227}
     1228
     1229size_t StringImpl::findIgnoringASCIICase(const StringImpl& matchString) const
     1230{
     1231    return ::WTF::findIgnoringASCIICase(*this, matchString, 0);
     1232}
     1233
     1234size_t StringImpl::findIgnoringASCIICase(const StringImpl& matchString, unsigned startOffset) const
     1235{
     1236    return ::WTF::findIgnoringASCIICase(*this, matchString, startOffset);
     1237}
     1238
     1239size_t StringImpl::findIgnoringASCIICase(const StringImpl* matchString) const
     1240{
     1241    if (!matchString)
     1242        return notFound;
     1243    return ::WTF::findIgnoringASCIICase(*this, *matchString, 0);
     1244}
     1245
     1246size_t StringImpl::findIgnoringASCIICase(const StringImpl* matchString, unsigned startOffset) const
     1247{
     1248    if (!matchString)
     1249        return notFound;
     1250    return ::WTF::findIgnoringASCIICase(*this, *matchString, startOffset);
    12271251}
    12281252

  • trunk/Source/WTF/wtf/text/StringImpl.h

    r181525 r181845  
    662662    ALWAYS_INLINE size_t findIgnoringCase(const char* s, unsigned index = 0) { return findIgnoringCase(reinterpret_cast<const LChar*>(s), index); }
    663663    WTF_EXPORT_STRING_API size_t findIgnoringCase(StringImpl*, unsigned index = 0);
     664    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringImpl&) const;
     665    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringImpl&, unsigned startOffset) const;
     666    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringImpl*) const;
     667    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringImpl*, unsigned startOffset) const;
    664668
    665669    WTF_EXPORT_STRING_API size_t findNextLineStart(unsigned index = UINT_MAX);

  • trunk/Source/WTF/wtf/text/StringView.cpp

    r181717 r181845  
    3333
    3434namespace WTF {
     35
     36bool StringView::containsIgnoringASCIICase(const StringView& matchString) const
     37{
     38    return findIgnoringASCIICase(matchString) != notFound;
     39}
     40
     41bool StringView::containsIgnoringASCIICase(const StringView& matchString, unsigned startOffset) const
     42{
     43    return findIgnoringASCIICase(matchString, startOffset) != notFound;
     44}
     45
     46size_t StringView::findIgnoringASCIICase(const StringView& matchString) const
     47{
     48    return ::WTF::findIgnoringASCIICase(*this, matchString, 0);
     49}
     50
     51size_t StringView::findIgnoringASCIICase(const StringView& matchString, unsigned startOffset) const
     52{
     53    return ::WTF::findIgnoringASCIICase(*this, matchString, startOffset);
     54}
    3555
    3656bool StringView::startsWith(const StringView& prefix) const

  • trunk/Source/WTF/wtf/text/StringView.h

    r181558 r181845  
    105105
    106106    size_t find(UChar, unsigned start = 0) const;
     107    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringView&) const;
     108    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringView&, unsigned startOffset) const;
     109
    107110    bool contains(UChar) const;
     111    WTF_EXPORT_STRING_API bool containsIgnoringASCIICase(const StringView&) const;
     112    WTF_EXPORT_STRING_API bool containsIgnoringASCIICase(const StringView&, unsigned startOffset) const;
    108113
    109114    WTF_EXPORT_STRING_API bool startsWith(const StringView&) const;

  • trunk/Source/WTF/wtf/text/WTFString.h

    r181525 r181845  
    221221    size_t find(const String& str, unsigned start) const
    222222        { return m_impl ? m_impl->find(str.impl(), start) : notFound; }
     223    size_t findIgnoringASCIICase(const String& str) const
     224        { return m_impl ? m_impl->findIgnoringASCIICase(str.impl()) : notFound; }
     225    size_t findIgnoringASCIICase(const String& str, unsigned startOffset) const
     226        { return m_impl ? m_impl->findIgnoringASCIICase(str.impl(), startOffset) : notFound; }
    223227
    224228    size_t find(CharacterMatchFunctionPtr matchFunction, unsigned start = 0) const
    … …  
    259263    bool contains(const LChar* str, bool caseSensitive = true, unsigned startOffset = 0) const
    260264        { return find(str, startOffset, caseSensitive) != notFound; }
    261     bool contains(const String& str, bool caseSensitive = true, unsigned startOffset = 0) const
     265    bool contains(const String& str) const
     266        { return find(str) != notFound; }
     267    bool contains(const String& str, bool caseSensitive, unsigned startOffset = 0) const
    262268        { return find(str, startOffset, caseSensitive) != notFound; }
     269    bool containsIgnoringASCIICase(const String& str) const
     270        { return findIgnoringASCIICase(str) != notFound; }
     271    bool containsIgnoringASCIICase(const String& str, unsigned startOffset) const
     272        { return findIgnoringASCIICase(str, startOffset) != notFound; }
    263273
    264274    bool startsWith(const String& s) const

  • trunk/Source/WebCore/ChangeLog

    r181840 r181845  
     12015-03-22  Benjamin Poulain  <benjamin@webkit.org>
     2
     3        CSS Selectors: fix attribute case-insensitive matching of Contain and List
     4        https://bugs.webkit.org/show_bug.cgi?id=142932
     5
     6        Reviewed by Darin Adler.
     7
     8        Fix the last two attribute selectors that were using full case-insensitive
     9        match:
     10            -Contain ([foo*=bar]).
     11            -List (foo~=bar]).
     12
     13        Tests: fast/selectors/attribute-contains-value-matching-is-ascii-case-insensitive.html
     14               fast/selectors/attribute-list-value-matching-is-ascii-case-insensitive.html
     15
     16        * css/SelectorChecker.cpp:
     17        (WebCore::attributeValueMatches):
     18        * cssjit/SelectorCompiler.cpp:
     19        (WebCore::SelectorCompiler::attributeValueContains):
     20        (WebCore::SelectorCompiler::attributeValueSpaceSeparetedListContains):
     21
    1222015-03-22  Benjamin Poulain  <bpoulain@apple.com>
    223

  • trunk/Source/WebCore/css/SelectorChecker.cpp

    r181525 r181845  
    432432            unsigned startSearchAt = 0;
    433433            while (true) {
    434                 size_t foundPos = value.find(selectorValue, startSearchAt, caseSensitive);
     434                size_t foundPos;
     435                if (caseSensitive)
     436                    foundPos = value.find(selectorValue, startSearchAt);
     437                else
     438                    foundPos = value.findIgnoringASCIICase(selectorValue, startSearchAt);
    435439                if (foundPos == notFound)
    436440                    return false;
    … …  
    446450            break;
    447451        }
    448     case CSSSelector::Contain:
    449         if (!value.contains(selectorValue, caseSensitive) || selectorValue.isEmpty())
    450             return false;
     452    case CSSSelector::Contain: {
     453        bool valueContainsSelectorValue;
     454        if (caseSensitive)
     455            valueContainsSelectorValue = value.contains(selectorValue);
     456        else
     457            valueContainsSelectorValue = value.containsIgnoringASCIICase(selectorValue);
     458
     459        if (!valueContainsSelectorValue || selectorValue.isEmpty())
     460            return false;
     461
    451462        break;
     463    }
    452464    case CSSSelector::Begin:
    453465        if (selectorValue.isEmpty())

  • trunk/Source/WebCore/cssjit/SelectorCompiler.cpp

    r181525 r181845  
    28182818    if (caseSensitivity == CaseSensitive)
    28192819        return valueImpl.find(expectedString) != notFound;
    2820     return valueImpl.findIgnoringCase(expectedString) != notFound;
     2820    return valueImpl.findIgnoringASCIICase(expectedString) != notFound;
    28212821}
    28222822
    … …  
    28642864            foundPos = value.find(expectedString, startSearchAt);
    28652865        else
    2866             foundPos = value.findIgnoringCase(expectedString, startSearchAt);
     2866            foundPos = value.findIgnoringASCIICase(expectedString, startSearchAt);
    28672867        if (foundPos == notFound)
    28682868            return false;

  • trunk/Tools/ChangeLog

    r181843 r181845  
     12015-03-22  Benjamin Poulain  <benjamin@webkit.org>
     2
     3        CSS Selectors: fix attribute case-insensitive matching of Contain and List
     4        https://bugs.webkit.org/show_bug.cgi?id=142932
     5
     6        Reviewed by Darin Adler.
     7
     8        Add tests for the new features and fix some existing tests using the
     9        stringFromUTF8() utility recently added by Dhi.
     10
     11        * TestWebKitAPI/Tests/WTF/StringImpl.cpp:
     12        (TestWebKitAPI::stringFromUTF8):
     13        * TestWebKitAPI/Tests/WTF/StringView.cpp:
     14
    1152015-03-22  Michael Catanzaro  <mcatanzaro@igalia.com>
    216

  • trunk/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp

    r181525 r181845  
    143143}
    144144
     145static RefPtr<StringImpl> stringFromUTF8(const char* characters)
     146{
     147    return String::fromUTF8(characters).impl();
     148}
     149
    145150TEST(WTF, StringImplEqualIgnoringASCIICaseWithLatin1Characters)
    146151{
    147     RefPtr<StringImpl> a = StringImpl::create(reinterpret_cast<const LChar*>("aBcéeFG"));
    148     RefPtr<StringImpl> b = StringImpl::create(reinterpret_cast<const LChar*>("ABCÉEFG"));
    149     RefPtr<StringImpl> c = StringImpl::create(reinterpret_cast<const LChar*>("ABCéEFG"));
    150     RefPtr<StringImpl> d = StringImpl::create(reinterpret_cast<const LChar*>("abcéefg"));
     152    RefPtr<StringImpl> a = stringFromUTF8("aBcéeFG");
     153    RefPtr<StringImpl> b = stringFromUTF8("ABCÉEFG");
     154    RefPtr<StringImpl> c = stringFromUTF8("ABCéEFG");
     155    RefPtr<StringImpl> d = stringFromUTF8("abcéefg");
    151156
    152157    // Identity.
    … …  
    165170}
    166171
     172TEST(WTF, StringImplFindIgnoringASCIICaseBasic)
     173{
     174    RefPtr<StringImpl> referenceA = stringFromUTF8("aBcéeFG");
     175    RefPtr<StringImpl> referenceB = stringFromUTF8("ABCÉEFG");
     176
     177    // Search the exact string.
     178    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(referenceA.get()));
     179    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(referenceB.get()));
     180
     181    // A and B are distinct by the non-ascii character é/É.
     182    EXPECT_EQ(static_cast<size_t>(notFound), referenceA->findIgnoringASCIICase(referenceB.get()));
     183    EXPECT_EQ(static_cast<size_t>(notFound), referenceB->findIgnoringASCIICase(referenceA.get()));
     184
     185    // Find the prefix.
     186    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("a").get()));
     187    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(stringFromUTF8("abcé").get()));
     188    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("A").get()));
     189    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(stringFromUTF8("ABCé").get()));
     190    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("a").get()));
     191    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(stringFromUTF8("abcÉ").get()));
     192    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("A").get()));
     193    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get()));
     194
     195    // Not a prefix.
     196    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("x").get()));
     197    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("accé").get()));
     198    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("abcÉ").get()));
     199    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("X").get()));
     200    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ABDé").get()));
     201    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get()));
     202    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("y").get()));
     203    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("accÉ").get()));
     204    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("abcé").get()));
     205    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("Y").get()));
     206    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ABdÉ").get()));
     207    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ABCé").get()));
     208
     209    // Find the infix.
     210    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("cée").get()));
     211    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("ée").get()));
     212    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("cé").get()));
     213    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("c").get()));
     214    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("é").get()));
     215    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("Cée").get()));
     216    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éE").get()));
     217    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("Cé").get()));
     218    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("C").get()));
     219
     220    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("cÉe").get()));
     221    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("Ée").get()));
     222    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("cÉ").get()));
     223    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("c").get()));
     224    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("É").get()));
     225    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("CÉe").get()));
     226    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("ÉE").get()));
     227    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("CÉ").get()));
     228    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("C").get()));
     229
     230    // Not an infix.
     231    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("céd").get()));
     232    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Ée").get()));
     233    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("bé").get()));
     234    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("x").get()));
     235    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("É").get()));
     236    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("CÉe").get()));
     237    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("éd").get()));
     238    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("CÉ").get()));
     239    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Y").get()));
     240
     241    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("cée").get()));
     242    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("Éc").get()));
     243    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("cé").get()));
     244    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("W").get()));
     245    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("é").get()));
     246    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("bÉe").get()));
     247    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éE").get()));
     248    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("BÉ").get()));
     249    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("z").get()));
     250
     251    // Find the suffix.
     252    EXPECT_EQ(static_cast<size_t>(6), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("g").get()));
     253    EXPECT_EQ(static_cast<size_t>(4), referenceA->findIgnoringASCIICase(stringFromUTF8("efg").get()));
     254    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éefg").get()));
     255    EXPECT_EQ(static_cast<size_t>(6), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("G").get()));
     256    EXPECT_EQ(static_cast<size_t>(4), referenceA->findIgnoringASCIICase(stringFromUTF8("EFG").get()));
     257    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éEFG").get()));
     258
     259    EXPECT_EQ(static_cast<size_t>(6), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("g").get()));
     260    EXPECT_EQ(static_cast<size_t>(4), referenceB->findIgnoringASCIICase(stringFromUTF8("efg").get()));
     261    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("Éefg").get()));
     262    EXPECT_EQ(static_cast<size_t>(6), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("G").get()));
     263    EXPECT_EQ(static_cast<size_t>(4), referenceB->findIgnoringASCIICase(stringFromUTF8("EFG").get()));
     264    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("ÉEFG").get()));
     265
     266    // Not a suffix.
     267    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("X").get()));
     268    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("edg").get()));
     269    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Éefg").get()));
     270    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("w").get()));
     271    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("dFG").get()));
     272    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ÉEFG").get()));
     273
     274    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("Z").get()));
     275    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ffg").get()));
     276    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éefg").get()));
     277    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("r").get()));
     278    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("EgG").get()));
     279    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éEFG").get()));
     280}
     281
     282TEST(WTF, StringImplFindIgnoringASCIICaseWithValidOffset)
     283{
     284    RefPtr<StringImpl> reference = stringFromUTF8("ABCÉEFGaBcéeFG");
     285    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(stringFromUTF8("ABC").get(), 0));
     286    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABC").get(), 1));
     287    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get(), 0));
     288    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get(), 1));
     289    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABCé").get(), 0));
     290    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABCé").get(), 1));
     291}
     292
     293TEST(WTF, StringImplFindIgnoringASCIICaseWithInvalidOffset)
     294{
     295    RefPtr<StringImpl> reference = stringFromUTF8("ABCÉEFGaBcéeFG");
     296    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABC").get(), 15));
     297    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABC").get(), 16));
     298    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get(), 17));
     299    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get(), 42));
     300    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get(), std::numeric_limits<unsigned>::max()));
     301}
     302
     303TEST(WTF, StringImplFindIgnoringASCIICaseOnNull)
     304{
     305    RefPtr<StringImpl> reference = stringFromUTF8("ABCÉEFG");
     306    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr));
     307    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 0));
     308    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 3));
     309    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 7));
     310    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 8));
     311    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 42));
     312    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, std::numeric_limits<unsigned>::max()));
     313}
     314
     315TEST(WTF, StringImplFindIgnoringASCIICaseOnEmpty)
     316{
     317    RefPtr<StringImpl> reference = stringFromUTF8("ABCÉEFG");
     318    RefPtr<StringImpl> empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
     319    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(empty.get()));
     320    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(empty.get(), 0));
     321    EXPECT_EQ(static_cast<size_t>(3), reference->findIgnoringASCIICase(empty.get(), 3));
     322    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.get(), 7));
     323    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.get(), 8));
     324    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.get(), 42));
     325    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.get(), std::numeric_limits<unsigned>::max()));
     326}
     327
     328TEST(WTF, StringImplFindIgnoringASCIICaseWithPatternLongerThanReference)
     329{
     330    RefPtr<StringImpl> reference = stringFromUTF8("ABCÉEFG");
     331    RefPtr<StringImpl> pattern = stringFromUTF8("XABCÉEFG");
     332    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(pattern.get()));
     333    EXPECT_EQ(static_cast<size_t>(1), pattern->findIgnoringASCIICase(reference.get()));
     334}
     335
    167336TEST(WTF, StringImplStartsWithIgnoringASCIICaseBasic)
    168337{
    169     RefPtr<StringImpl> reference = StringImpl::create(reinterpret_cast<const LChar*>("aBcéX"));
    170     RefPtr<StringImpl> referenceEquivalent = StringImpl::create(reinterpret_cast<const LChar*>("AbCéx"));
     338    RefPtr<StringImpl> reference = stringFromUTF8("aBcéX");
     339    RefPtr<StringImpl> referenceEquivalent = stringFromUTF8("AbCéx");
    171340
    172341    // Identity.
    … …  
    195364    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcUpper.get()));
    196365
    197     RefPtr<StringImpl> abcAccentLower = StringImpl::create(reinterpret_cast<const LChar*>("abcé"));
     366    RefPtr<StringImpl> abcAccentLower = stringFromUTF8("abcé");
    198367    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcAccentLower.get()));
    199368    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcAccentLower.get()));
    200     RefPtr<StringImpl> abcAccentUpper = StringImpl::create(reinterpret_cast<const LChar*>("ABCé"));
     369    RefPtr<StringImpl> abcAccentUpper = stringFromUTF8("ABCé");
    201370    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcAccentUpper.get()));
    202371    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcAccentUpper.get()));
    203372
    204373    // Negative cases.
    205     RefPtr<StringImpl> differentFirstChar = StringImpl::create(reinterpret_cast<const LChar*>("bBcéX"));
    206     RefPtr<StringImpl> differentFirstCharProperPrefix = StringImpl::create(reinterpret_cast<const LChar*>("CBcé"));
     374    RefPtr<StringImpl> differentFirstChar = stringFromUTF8("bBcéX");
     375    RefPtr<StringImpl> differentFirstCharProperPrefix = stringFromUTF8("CBcé");
    207376    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(differentFirstChar.get()));
    208377    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*differentFirstChar.get()));
    … …  
    210379    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*differentFirstCharProperPrefix.get()));
    211380
    212     RefPtr<StringImpl> uppercaseAccent = StringImpl::create(reinterpret_cast<const LChar*>("aBcÉX"));
    213     RefPtr<StringImpl> uppercaseAccentProperPrefix = StringImpl::create(reinterpret_cast<const LChar*>("aBcÉX"));
     381    RefPtr<StringImpl> uppercaseAccent = stringFromUTF8("aBcÉX");
     382    RefPtr<StringImpl> uppercaseAccentProperPrefix = stringFromUTF8("aBcÉX");
    214383    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(uppercaseAccent.get()));
    215384    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*uppercaseAccent.get()));
    … …  
    241410TEST(WTF, StringImplEndsWithIgnoringASCIICaseBasic)
    242411{
    243     RefPtr<StringImpl> reference = StringImpl::create(reinterpret_cast<const LChar*>("XÉCbA"));
    244     RefPtr<StringImpl> referenceEquivalent = StringImpl::create(reinterpret_cast<const LChar*>("xÉcBa"));
     412    RefPtr<StringImpl> reference = stringFromUTF8("XÉCbA");
     413    RefPtr<StringImpl> referenceEquivalent = stringFromUTF8("xÉcBa");
    245414
    246415    // Identity.
    … …  
    269438    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcUpper.get()));
    270439
    271     RefPtr<StringImpl> abcAccentLower = StringImpl::create(reinterpret_cast<const LChar*>("Écba"));
     440    RefPtr<StringImpl> abcAccentLower = stringFromUTF8("Écba");
    272441    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcAccentLower.get()));
    273442    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcAccentLower.get()));
    274     RefPtr<StringImpl> abcAccentUpper = StringImpl::create(reinterpret_cast<const LChar*>("ÉCBA"));
     443    RefPtr<StringImpl> abcAccentUpper = stringFromUTF8("ÉCBA");
    275444    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcAccentUpper.get()));
    276445    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcAccentUpper.get()));
    277446
    278447    // Negative cases.
    279     RefPtr<StringImpl> differentLastChar = StringImpl::create(reinterpret_cast<const LChar*>("XÉCbB"));
    280     RefPtr<StringImpl> differentLastCharProperSuffix = StringImpl::create(reinterpret_cast<const LChar*>("ÉCbb"));
     448    RefPtr<StringImpl> differentLastChar = stringFromUTF8("XÉCbB");
     449    RefPtr<StringImpl> differentLastCharProperSuffix = stringFromUTF8("ÉCbb");
    281450    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(differentLastChar.get()));
    282451    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*differentLastChar.get()));
    … …  
    284453    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*differentLastCharProperSuffix.get()));
    285454
    286     RefPtr<StringImpl> lowercaseAccent = StringImpl::create(reinterpret_cast<const LChar*>("aBcéX"));
    287     RefPtr<StringImpl> loweraseAccentProperSuffix = StringImpl::create(reinterpret_cast<const LChar*>("aBcéX"));
     455    RefPtr<StringImpl> lowercaseAccent = stringFromUTF8("aBcéX");
     456    RefPtr<StringImpl> loweraseAccentProperSuffix = stringFromUTF8("aBcéX");
    288457    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(lowercaseAccent.get()));
    289458    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*lowercaseAccent.get()));

  • trunk/Tools/TestWebKitAPI/Tests/WTF/StringView.cpp

    r181717 r181845  
    227227}
    228228
     229TEST(WTF, StringViewFindIgnoringASCIICaseBasic)
     230{
     231    String referenceAHolder;
     232    StringView referenceA = stringViewFromUTF8(referenceAHolder, "aBcéeFG");
     233    String referenceBHolder;
     234    StringView referenceB = stringViewFromUTF8(referenceBHolder, "ABCÉEFG");
     235
     236    // Search the exact string.
     237    EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(referenceA));
     238    EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(referenceB));
     239
     240    // A and B are distinct by the non-ascii character é/É.
     241    EXPECT_EQ(static_cast<size_t>(notFound), referenceA.findIgnoringASCIICase(referenceB));
     242    EXPECT_EQ(static_cast<size_t>(notFound), referenceB.findIgnoringASCIICase(referenceA));
     243
     244    String tempStringHolder;
     245    // Find the prefix.
     246    EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromLiteral("a")));
     247    EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcé")));
     248    EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromLiteral("A")));
     249    EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCé")));
     250    EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromLiteral("a")));
     251    EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcÉ")));
     252    EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromLiteral("A")));
     253    EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ")));
     254
     255    // Not a prefix.
     256    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromLiteral("x")));
     257    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "accé")));
     258    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcÉ")));
     259    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromLiteral("X")));
     260    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABDé")));
     261    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ")));
     262    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromLiteral("y")));
     263    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "accÉ")));
     264    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcé")));
     265    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromLiteral("Y")));
     266    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABdÉ")));
     267    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCé")));
     268
     269    // Find the infix.
     270    EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cée")));
     271    EXPECT_EQ(static_cast<size_t>(3), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ée")));
     272    EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cé")));
     273    EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "c")));
     274    EXPECT_EQ(static_cast<size_t>(3), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "é")));
     275    EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Cée")));
     276    EXPECT_EQ(static_cast<size_t>(3), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éE")));
     277    EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Cé")));
     278    EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "C")));
     279
     280    EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cÉe")));
     281    EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Ée")));
     282    EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cÉ")));
     283    EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "c")));
     284    EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "É")));
     285    EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "CÉe")));
     286    EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ÉE")));
     287    EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "CÉ")));
     288    EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "C")));
     289
     290    // Not an infix.
     291    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "céd")));
     292    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Ée")));
     293    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "bé")));
     294    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "x")));
     295    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "É")));
     296    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "CÉe")));
     297    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éd")));
     298    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "CÉ")));
     299    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Y")));
     300
     301    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cée")));
     302    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Éc")));
     303    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cé")));
     304    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "W")));
     305    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "é")));
     306    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "bÉe")));
     307    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éE")));
     308    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "BÉ")));
     309    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "z")));
     310
     311    // Find the suffix.
     312    EXPECT_EQ(static_cast<size_t>(6), referenceA.findIgnoringASCIICase(stringViewFromLiteral("g")));
     313    EXPECT_EQ(static_cast<size_t>(4), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "efg")));
     314    EXPECT_EQ(static_cast<size_t>(3), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éefg")));
     315    EXPECT_EQ(static_cast<size_t>(6), referenceA.findIgnoringASCIICase(stringViewFromLiteral("G")));
     316    EXPECT_EQ(static_cast<size_t>(4), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "EFG")));
     317    EXPECT_EQ(static_cast<size_t>(3), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éEFG")));
     318
     319    EXPECT_EQ(static_cast<size_t>(6), referenceB.findIgnoringASCIICase(stringViewFromLiteral("g")));
     320    EXPECT_EQ(static_cast<size_t>(4), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "efg")));
     321    EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Éefg")));
     322    EXPECT_EQ(static_cast<size_t>(6), referenceB.findIgnoringASCIICase(stringViewFromLiteral("G")));
     323    EXPECT_EQ(static_cast<size_t>(4), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "EFG")));
     324    EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ÉEFG")));
     325
     326    // Not a suffix.
     327    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromLiteral("X")));
     328    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "edg")));
     329    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Éefg")));
     330    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromLiteral("w")));
     331    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "dFG")));
     332    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ÉEFG")));
     333
     334    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromLiteral("Z")));
     335    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ffg")));
     336    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éefg")));
     337    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromLiteral("r")));
     338    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "EgG")));
     339    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éEFG")));
     340}
     341
     342TEST(WTF, StringViewFindIgnoringASCIICaseWithValidOffset)
     343{
     344    String referenceHolder;
     345    StringView reference = stringViewFromUTF8(referenceHolder, "ABCÉEFGaBcéeFG");
     346    String tempStringHolder;
     347
     348    EXPECT_EQ(static_cast<size_t>(0), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABC"), 0));
     349    EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABC"), 1));
     350    EXPECT_EQ(static_cast<size_t>(0), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"), 0));
     351    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"), 1));
     352    EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCé"), 0));
     353    EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCé"), 1));
     354}
     355
     356TEST(WTF, StringViewFindIgnoringASCIICaseWithInvalidOffset)
     357{
     358    String referenceHolder;
     359    StringView reference = stringViewFromUTF8(referenceHolder, "ABCÉEFGaBcéeFG");
     360    String tempStringHolder;
     361
     362    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABC"), 15));
     363    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABC"), 16));
     364    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"), 17));
     365    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"), 42));
     366    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"), std::numeric_limits<unsigned>::max()));
     367}
     368
     369TEST(WTF, StringViewFindIgnoringASCIICaseOnEmpty)
     370{
     371    String referenceHolder;
     372    StringView reference = stringViewFromUTF8(referenceHolder, "ABCÉEFG");
     373    StringView empty = stringViewFromLiteral("");
     374    EXPECT_EQ(static_cast<size_t>(0), reference.findIgnoringASCIICase(empty));
     375    EXPECT_EQ(static_cast<size_t>(0), reference.findIgnoringASCIICase(empty, 0));
     376    EXPECT_EQ(static_cast<size_t>(3), reference.findIgnoringASCIICase(empty, 3));
     377    EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(empty, 7));
     378    EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(empty, 8));
     379    EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(empty, 42));
     380    EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(empty, std::numeric_limits<unsigned>::max()));
     381}
     382
     383TEST(WTF, StringViewFindIgnoringASCIICaseWithPatternLongerThanReference)
     384{
     385    String referenceHolder;
     386    StringView reference = stringViewFromUTF8(referenceHolder, "ABCÉEFG");
     387    String patternHolder;
     388    StringView pattern = stringViewFromUTF8(referenceHolder, "ABCÉEFGA");
     389
     390    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(pattern));
     391    EXPECT_EQ(static_cast<size_t>(0), pattern.findIgnoringASCIICase(reference));
     392}
     393
    229394TEST(WTF, StringViewStartsWithBasic)
    230395{
Note: See TracChangeset for help on using the changeset viewer.