webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 533 insertions, 17 deletions

diff --git a/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp b/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp
index d5804f6b4..fdb701c90 100644
--- a/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp
+++ b/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2012, 2016 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -25,7 +25,8 @@
 
 #include "config.h"
 
-#include <wtf/text/StringImpl.h>
+#include <wtf/Hasher.h>
+#include <wtf/text/SymbolImpl.h>
 #include <wtf/text/WTFString.h>
 
 namespace TestWebKitAPI {
@@ -33,14 +34,14 @@ namespace TestWebKitAPI {
 TEST(WTF, StringImplCreationFromLiteral)
 {
     // Constructor using the template to determine the size.
-    RefPtr<StringImpl> stringWithTemplate = StringImpl::createFromLiteral("Template Literal");
+    auto stringWithTemplate = StringImpl::createFromLiteral("Template Literal");
     ASSERT_EQ(strlen("Template Literal"), stringWithTemplate->length());
     ASSERT_TRUE(equal(stringWithTemplate.get(), "Template Literal"));
     ASSERT_TRUE(stringWithTemplate->is8Bit());
 
     // Constructor taking the size explicitely.
     const char* programmaticStringData = "Explicit Size Literal";
-    RefPtr<StringImpl> programmaticString = StringImpl::createFromLiteral(programmaticStringData, strlen(programmaticStringData));
+    auto programmaticString = StringImpl::createFromLiteral(programmaticStringData, strlen(programmaticStringData));
     ASSERT_EQ(strlen(programmaticStringData), programmaticString->length());
     ASSERT_TRUE(equal(programmaticString.get(), programmaticStringData));
     ASSERT_EQ(programmaticStringData, reinterpret_cast<const char*>(programmaticString->characters8()));
@@ -48,27 +49,16 @@ TEST(WTF, StringImplCreationFromLiteral)
 
     // Constructor without explicit size.
     const char* stringWithoutLengthLiteral = "No Size Literal";
-    RefPtr<StringImpl> programmaticStringNoLength = StringImpl::createFromLiteral(stringWithoutLengthLiteral);
+    auto programmaticStringNoLength = StringImpl::createFromLiteral(stringWithoutLengthLiteral);
     ASSERT_EQ(strlen(stringWithoutLengthLiteral), programmaticStringNoLength->length());
     ASSERT_TRUE(equal(programmaticStringNoLength.get(), stringWithoutLengthLiteral));
     ASSERT_EQ(stringWithoutLengthLiteral, reinterpret_cast<const char*>(programmaticStringNoLength->characters8()));
     ASSERT_TRUE(programmaticStringNoLength->is8Bit());
 }
 
-TEST(WTF, StringImplFromLiteralLoop16BitConversion)
-{
-    RefPtr<StringImpl> controlString = StringImpl::create("Template Literal");
-    for (size_t i = 0; i < 10; ++i) {
-        RefPtr<StringImpl> string = StringImpl::createFromLiteral("Template Literal");
-
-        ASSERT_EQ(0, memcmp(controlString->deprecatedCharacters(), string->deprecatedCharacters(), controlString->length() * sizeof(UChar)));
-        ASSERT_TRUE(string->has16BitShadow());
-    }
-}
-
 TEST(WTF, StringImplReplaceWithLiteral)
 {
-    RefPtr<StringImpl> testStringImpl = StringImpl::createFromLiteral("1224");
+    auto testStringImpl = StringImpl::createFromLiteral("1224");
     ASSERT_TRUE(testStringImpl->is8Bit());
 
     // Cases for 8Bit source.
@@ -110,4 +100,530 @@ TEST(WTF, StringImplReplaceWithLiteral)
     ASSERT_TRUE(equal(testStringImpl.get(), "r555sum555"));
 }
 
+TEST(WTF, StringImplEqualIgnoringASCIICaseBasic)
+{
+    auto a = StringImpl::createFromLiteral("aBcDeFG");
+    auto b = StringImpl::createFromLiteral("ABCDEFG");
+    auto c = StringImpl::createFromLiteral("abcdefg");
+    const char d[] = "aBcDeFG";
+    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
+    auto shorter = StringImpl::createFromLiteral("abcdef");
+    auto different = StringImpl::createFromLiteral("abcrefg");
+
+    // Identity.
+    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), a.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(b.ptr(), b.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(c.ptr(), c.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), d));
+    ASSERT_TRUE(equalIgnoringASCIICase(b.ptr(), d));
+    ASSERT_TRUE(equalIgnoringASCIICase(c.ptr(), d));
+
+    // Transitivity.
+    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), b.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(b.ptr(), c.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), c.ptr()));
+
+    // Negative cases.
+    ASSERT_FALSE(equalIgnoringASCIICase(a.ptr(), empty.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), empty.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(c.ptr(), empty.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(a.ptr(), shorter.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), shorter.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(c.ptr(), shorter.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(a.ptr(), different.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), different.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(c.ptr(), different.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(empty.ptr(), d));
+    ASSERT_FALSE(equalIgnoringASCIICase(shorter.ptr(), d));
+    ASSERT_FALSE(equalIgnoringASCIICase(different.ptr(), d));
+}
+
+TEST(WTF, StringImplEqualIgnoringASCIICaseWithNull)
+{
+    auto reference = StringImpl::createFromLiteral("aBcDeFG");
+    StringImpl* nullStringImpl = nullptr;
+    ASSERT_FALSE(equalIgnoringASCIICase(nullStringImpl, reference.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(reference.ptr(), nullStringImpl));
+    ASSERT_TRUE(equalIgnoringASCIICase(nullStringImpl, nullStringImpl));
+}
+
+TEST(WTF, StringImplEqualIgnoringASCIICaseWithEmpty)
+{
+    auto a = StringImpl::create(reinterpret_cast<const LChar*>(""));
+    auto b = StringImpl::create(reinterpret_cast<const LChar*>(""));
+    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), b.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(b.ptr(), a.ptr()));
+}
+
+static Ref<StringImpl> stringFromUTF8(const char* characters)
+{
+    return String::fromUTF8(characters).releaseImpl().releaseNonNull();
+}
+
+TEST(WTF, StringImplEqualIgnoringASCIICaseWithLatin1Characters)
+{
+    auto a = stringFromUTF8("aBcéeFG");
+    auto b = stringFromUTF8("ABCÉEFG");
+    auto c = stringFromUTF8("ABCéEFG");
+    auto d = stringFromUTF8("abcéefg");
+    const char e[] = "aBcéeFG";
+
+    // Identity.
+    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), a.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(b.ptr(), b.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(c.ptr(), c.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(d.ptr(), d.ptr()));
+
+    // All combination.
+    ASSERT_FALSE(equalIgnoringASCIICase(a.ptr(), b.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), c.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), d.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), c.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), d.ptr()));
+    ASSERT_TRUE(equalIgnoringASCIICase(c.ptr(), d.ptr()));
+    ASSERT_FALSE(equalIgnoringASCIICase(a.ptr(), e));
+    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), e));
+    ASSERT_FALSE(equalIgnoringASCIICase(c.ptr(), e));
+    ASSERT_FALSE(equalIgnoringASCIICase(d.ptr(), e));
+}
+
+TEST(WTF, StringImplFindIgnoringASCIICaseBasic)
+{
+    auto referenceA = stringFromUTF8("aBcéeFG");
+    auto referenceB = stringFromUTF8("ABCÉEFG");
+
+    // Search the exact string.
+    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(referenceA.ptr()));
+    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(referenceB.ptr()));
+
+    // A and B are distinct by the non-ascii character é/É.
+    EXPECT_EQ(static_cast<size_t>(notFound), referenceA->findIgnoringASCIICase(referenceB.ptr()));
+    EXPECT_EQ(static_cast<size_t>(notFound), referenceB->findIgnoringASCIICase(referenceA.ptr()));
+
+    // Find the prefix.
+    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("a").ptr()));
+    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(stringFromUTF8("abcé").ptr()));
+    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("A").ptr()));
+    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(stringFromUTF8("ABCé").ptr()));
+    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("a").ptr()));
+    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(stringFromUTF8("abcÉ").ptr()));
+    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("A").ptr()));
+    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr()));
+
+    // Not a prefix.
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("x").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("accé").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("abcÉ").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("X").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ABDé").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("y").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("accÉ").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("abcé").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("Y").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ABdÉ").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ABCé").ptr()));
+
+    // Find the infix.
+    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("cée").ptr()));
+    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("ée").ptr()));
+    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("cé").ptr()));
+    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("c").ptr()));
+    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("é").ptr()));
+    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("Cée").ptr()));
+    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éE").ptr()));
+    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("Cé").ptr()));
+    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("C").ptr()));
+
+    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("cÉe").ptr()));
+    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("Ée").ptr()));
+    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("cÉ").ptr()));
+    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("c").ptr()));
+    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("É").ptr()));
+    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("CÉe").ptr()));
+    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("ÉE").ptr()));
+    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("CÉ").ptr()));
+    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("C").ptr()));
+
+    // Not an infix.
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("céd").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Ée").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("bé").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("x").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("É").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("CÉe").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("éd").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("CÉ").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Y").ptr()));
+
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("cée").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("Éc").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("cé").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("W").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("é").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("bÉe").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éE").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("BÉ").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("z").ptr()));
+
+    // Find the suffix.
+    EXPECT_EQ(static_cast<size_t>(6), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("g").ptr()));
+    EXPECT_EQ(static_cast<size_t>(4), referenceA->findIgnoringASCIICase(stringFromUTF8("efg").ptr()));
+    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éefg").ptr()));
+    EXPECT_EQ(static_cast<size_t>(6), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("G").ptr()));
+    EXPECT_EQ(static_cast<size_t>(4), referenceA->findIgnoringASCIICase(stringFromUTF8("EFG").ptr()));
+    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éEFG").ptr()));
+
+    EXPECT_EQ(static_cast<size_t>(6), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("g").ptr()));
+    EXPECT_EQ(static_cast<size_t>(4), referenceB->findIgnoringASCIICase(stringFromUTF8("efg").ptr()));
+    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("Éefg").ptr()));
+    EXPECT_EQ(static_cast<size_t>(6), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("G").ptr()));
+    EXPECT_EQ(static_cast<size_t>(4), referenceB->findIgnoringASCIICase(stringFromUTF8("EFG").ptr()));
+    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("ÉEFG").ptr()));
+
+    // Not a suffix.
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("X").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("edg").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Éefg").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("w").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("dFG").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ÉEFG").ptr()));
+
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("Z").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ffg").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éefg").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("r").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("EgG").ptr()));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éEFG").ptr()));
+}
+
+TEST(WTF, StringImplFindIgnoringASCIICaseWithValidOffset)
+{
+    auto reference = stringFromUTF8("ABCÉEFGaBcéeFG");
+    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(stringFromUTF8("ABC").ptr(), 0));
+    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABC").ptr(), 1));
+    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr(), 0));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr(), 1));
+    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABCé").ptr(), 0));
+    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABCé").ptr(), 1));
+}
+
+TEST(WTF, StringImplFindIgnoringASCIICaseWithInvalidOffset)
+{
+    auto reference = stringFromUTF8("ABCÉEFGaBcéeFG");
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABC").ptr(), 15));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABC").ptr(), 16));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr(), 17));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr(), 42));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr(), std::numeric_limits<unsigned>::max()));
+}
+
+TEST(WTF, StringImplFindIgnoringASCIICaseOnNull)
+{
+    auto reference = stringFromUTF8("ABCÉEFG");
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 0));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 3));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 7));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 8));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 42));
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, std::numeric_limits<unsigned>::max()));
+}
+
+TEST(WTF, StringImplFindIgnoringASCIICaseOnEmpty)
+{
+    auto reference = stringFromUTF8("ABCÉEFG");
+    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
+    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(empty.ptr()));
+    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(empty.ptr(), 0));
+    EXPECT_EQ(static_cast<size_t>(3), reference->findIgnoringASCIICase(empty.ptr(), 3));
+    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.ptr(), 7));
+    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.ptr(), 8));
+    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.ptr(), 42));
+    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.ptr(), std::numeric_limits<unsigned>::max()));
+}
+
+TEST(WTF, StringImplFindIgnoringASCIICaseWithPatternLongerThanReference)
+{
+    auto reference = stringFromUTF8("ABCÉEFG");
+    auto pattern = stringFromUTF8("XABCÉEFG");
+    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(pattern.ptr()));
+    EXPECT_EQ(static_cast<size_t>(1), pattern->findIgnoringASCIICase(reference.ptr()));
+}
+
+TEST(WTF, StringImplStartsWithIgnoringASCIICaseBasic)
+{
+    auto reference = stringFromUTF8("aBcéX");
+    auto referenceEquivalent = stringFromUTF8("AbCéx");
+
+    // Identity.
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(reference.ptr()));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*reference.ptr()));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(referenceEquivalent.ptr()));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*referenceEquivalent.ptr()));
+    ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(reference.ptr()));
+    ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(*reference.ptr()));
+    ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(referenceEquivalent.ptr()));
+    ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(*referenceEquivalent.ptr()));
+
+    // Proper prefixes.
+    auto aLower = StringImpl::createFromLiteral("a");
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(aLower.ptr()));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*aLower.ptr()));
+    auto aUpper = StringImpl::createFromLiteral("A");
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(aUpper.ptr()));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*aUpper.ptr()));
+
+    auto abcLower = StringImpl::createFromLiteral("abc");
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcLower.ptr()));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcLower.ptr()));
+    auto abcUpper = StringImpl::createFromLiteral("ABC");
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcUpper.ptr()));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcUpper.ptr()));
+
+    auto abcAccentLower = stringFromUTF8("abcé");
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcAccentLower.ptr()));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcAccentLower.ptr()));
+    auto abcAccentUpper = stringFromUTF8("ABCé");
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcAccentUpper.ptr()));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcAccentUpper.ptr()));
+
+    // Negative cases.
+    auto differentFirstChar = stringFromUTF8("bBcéX");
+    auto differentFirstCharProperPrefix = stringFromUTF8("CBcé");
+    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(differentFirstChar.ptr()));
+    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*differentFirstChar.ptr()));
+    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(differentFirstCharProperPrefix.ptr()));
+    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*differentFirstCharProperPrefix.ptr()));
+
+    auto uppercaseAccent = stringFromUTF8("aBcÉX");
+    auto uppercaseAccentProperPrefix = stringFromUTF8("aBcÉX");
+    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(uppercaseAccent.ptr()));
+    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*uppercaseAccent.ptr()));
+    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(uppercaseAccentProperPrefix.ptr()));
+    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*uppercaseAccentProperPrefix.ptr()));
+}
+
+TEST(WTF, StringImplStartsWithIgnoringASCIICaseWithNull)
+{
+    auto reference = StringImpl::createFromLiteral("aBcDeFG");
+    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(nullptr));
+
+    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
+    ASSERT_FALSE(empty->startsWithIgnoringASCIICase(nullptr));
+}
+
+TEST(WTF, StringImplStartsWithIgnoringASCIICaseWithEmpty)
+{
+    auto reference = StringImpl::createFromLiteral("aBcDeFG");
+    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(empty.ptr()));
+    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*empty.ptr()));
+    ASSERT_TRUE(empty->startsWithIgnoringASCIICase(empty.ptr()));
+    ASSERT_TRUE(empty->startsWithIgnoringASCIICase(*empty.ptr()));
+    ASSERT_FALSE(empty->startsWithIgnoringASCIICase(reference.ptr()));
+    ASSERT_FALSE(empty->startsWithIgnoringASCIICase(*reference.ptr()));
+}
+
+TEST(WTF, StartsWithLettersIgnoringASCIICase)
+{
+    String string("Test tEST");
+    ASSERT_TRUE(startsWithLettersIgnoringASCIICase(string, "test t"));
+    ASSERT_TRUE(startsWithLettersIgnoringASCIICase(string, "test te"));
+    ASSERT_TRUE(startsWithLettersIgnoringASCIICase(string, "test test"));
+    ASSERT_FALSE(startsWithLettersIgnoringASCIICase(string, "test tex"));
+
+    ASSERT_TRUE(startsWithLettersIgnoringASCIICase(string, ""));
+    ASSERT_TRUE(startsWithLettersIgnoringASCIICase(String(""), ""));
+
+    ASSERT_FALSE(startsWithLettersIgnoringASCIICase(String(), "t"));
+    ASSERT_FALSE(startsWithLettersIgnoringASCIICase(String(), ""));
+}
+
+TEST(WTF, StringImplEndsWithIgnoringASCIICaseBasic)
+{
+    auto reference = stringFromUTF8("XÉCbA");
+    auto referenceEquivalent = stringFromUTF8("xÉcBa");
+
+    // Identity.
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(reference.ptr()));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*reference.ptr()));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(referenceEquivalent.ptr()));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*referenceEquivalent.ptr()));
+    ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(reference.ptr()));
+    ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(*reference.ptr()));
+    ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(referenceEquivalent.ptr()));
+    ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(*referenceEquivalent.ptr()));
+
+    // Proper suffixes.
+    auto aLower = StringImpl::createFromLiteral("a");
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(aLower.ptr()));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*aLower.ptr()));
+    auto aUpper = StringImpl::createFromLiteral("a");
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(aUpper.ptr()));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*aUpper.ptr()));
+
+    auto abcLower = StringImpl::createFromLiteral("cba");
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcLower.ptr()));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcLower.ptr()));
+    auto abcUpper = StringImpl::createFromLiteral("CBA");
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcUpper.ptr()));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcUpper.ptr()));
+
+    auto abcAccentLower = stringFromUTF8("Écba");
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcAccentLower.ptr()));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcAccentLower.ptr()));
+    auto abcAccentUpper = stringFromUTF8("ÉCBA");
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcAccentUpper.ptr()));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcAccentUpper.ptr()));
+
+    // Negative cases.
+    auto differentLastChar = stringFromUTF8("XÉCbB");
+    auto differentLastCharProperSuffix = stringFromUTF8("ÉCbb");
+    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(differentLastChar.ptr()));
+    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*differentLastChar.ptr()));
+    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(differentLastCharProperSuffix.ptr()));
+    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*differentLastCharProperSuffix.ptr()));
+
+    auto lowercaseAccent = stringFromUTF8("aBcéX");
+    auto loweraseAccentProperSuffix = stringFromUTF8("aBcéX");
+    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(lowercaseAccent.ptr()));
+    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*lowercaseAccent.ptr()));
+    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(loweraseAccentProperSuffix.ptr()));
+    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*loweraseAccentProperSuffix.ptr()));
+}
+
+TEST(WTF, StringImplEndsWithIgnoringASCIICaseWithNull)
+{
+    auto reference = StringImpl::createFromLiteral("aBcDeFG");
+    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(nullptr));
+
+    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
+    ASSERT_FALSE(empty->endsWithIgnoringASCIICase(nullptr));
+}
+
+TEST(WTF, StringImplEndsWithIgnoringASCIICaseWithEmpty)
+{
+    auto reference = StringImpl::createFromLiteral("aBcDeFG");
+    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(empty.ptr()));
+    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*empty.ptr()));
+    ASSERT_TRUE(empty->endsWithIgnoringASCIICase(empty.ptr()));
+    ASSERT_TRUE(empty->endsWithIgnoringASCIICase(*empty.ptr()));
+    ASSERT_FALSE(empty->endsWithIgnoringASCIICase(reference.ptr()));
+    ASSERT_FALSE(empty->endsWithIgnoringASCIICase(*reference.ptr()));
+}
+
+TEST(WTF, StringImplCreateNullSymbol)
+{
+    auto reference = SymbolImpl::createNullSymbol();
+    ASSERT_TRUE(reference->isSymbol());
+    ASSERT_TRUE(reference->isNullSymbol());
+    ASSERT_FALSE(reference->isAtomic());
+    ASSERT_EQ(0u, reference->length());
+    ASSERT_TRUE(equal(reference.ptr(), ""));
+}
+
+TEST(WTF, StringImplCreateSymbol)
+{
+    auto original = stringFromUTF8("original");
+    auto reference = SymbolImpl::create(original);
+    ASSERT_TRUE(reference->isSymbol());
+    ASSERT_FALSE(reference->isNullSymbol());
+    ASSERT_FALSE(reference->isAtomic());
+    ASSERT_FALSE(original->isSymbol());
+    ASSERT_FALSE(original->isAtomic());
+    ASSERT_EQ(original->length(), reference->length());
+    ASSERT_TRUE(equal(reference.ptr(), "original"));
+
+    auto empty = stringFromUTF8("");
+    auto emptyReference = SymbolImpl::create(empty);
+    ASSERT_TRUE(emptyReference->isSymbol());
+    ASSERT_FALSE(emptyReference->isNullSymbol());
+    ASSERT_FALSE(emptyReference->isAtomic());
+    ASSERT_FALSE(empty->isSymbol());
+    ASSERT_TRUE(empty->isAtomic());
+    ASSERT_EQ(empty->length(), emptyReference->length());
+    ASSERT_TRUE(equal(emptyReference.ptr(), ""));
+}
+
+TEST(WTF, StringImplSymbolToAtomicString)
+{
+    auto original = stringFromUTF8("original");
+    auto reference = SymbolImpl::create(original);
+    ASSERT_TRUE(reference->isSymbol());
+    ASSERT_FALSE(reference->isAtomic());
+
+    auto result = AtomicStringImpl::lookUp(reference.ptr());
+    ASSERT_FALSE(result);
+
+    auto atomic = AtomicStringImpl::add(reference.ptr());
+    ASSERT_TRUE(atomic->isAtomic());
+    ASSERT_FALSE(atomic->isSymbol());
+    ASSERT_TRUE(reference->isSymbol());
+    ASSERT_FALSE(reference->isAtomic());
+
+    auto result2 = AtomicStringImpl::lookUp(reference.ptr());
+    ASSERT_TRUE(result2);
+}
+
+TEST(WTF, StringImplNullSymbolToAtomicString)
+{
+    auto reference = SymbolImpl::createNullSymbol();
+    ASSERT_TRUE(reference->isSymbol());
+    ASSERT_FALSE(reference->isAtomic());
+
+    // Because the substring of the reference is the empty string which is already interned.
+    auto result = AtomicStringImpl::lookUp(reference.ptr());
+    ASSERT_TRUE(result);
+
+    auto atomic = AtomicStringImpl::add(reference.ptr());
+    ASSERT_TRUE(atomic->isAtomic());
+    ASSERT_FALSE(atomic->isSymbol());
+    ASSERT_TRUE(reference->isSymbol());
+    ASSERT_FALSE(reference->isAtomic());
+    ASSERT_EQ(atomic.get(), StringImpl::empty());
+
+    auto result2 = AtomicStringImpl::lookUp(reference.ptr());
+    ASSERT_TRUE(result2);
+}
+
+static StringImpl::StaticStringImpl staticString {"Cocoa"};
+
+TEST(WTF, StringImplStaticToAtomicString)
+{
+    StringImpl& original = staticString;
+    ASSERT_FALSE(original.isSymbol());
+    ASSERT_FALSE(original.isAtomic());
+    ASSERT_TRUE(original.isStatic());
+
+    auto result = AtomicStringImpl::lookUp(&original);
+    ASSERT_FALSE(result);
+
+    auto atomic = AtomicStringImpl::add(&original);
+    ASSERT_TRUE(atomic->isAtomic());
+    ASSERT_FALSE(atomic->isSymbol());
+    ASSERT_FALSE(atomic->isStatic());
+    ASSERT_FALSE(original.isSymbol());
+    ASSERT_FALSE(original.isAtomic());
+    ASSERT_TRUE(original.isStatic());
+
+    auto result2 = AtomicStringImpl::lookUp(&original);
+    ASSERT_TRUE(result2);
+}
+
+TEST(WTF, StringImplConstexprHasher)
+{
+    ASSERT_EQ(stringFromUTF8("")->hash(), StringHasher::computeLiteralHashAndMaskTop8Bits(""));
+    ASSERT_EQ(stringFromUTF8("A")->hash(), StringHasher::computeLiteralHashAndMaskTop8Bits("A"));
+    ASSERT_EQ(stringFromUTF8("AA")->hash(), StringHasher::computeLiteralHashAndMaskTop8Bits("AA"));
+    ASSERT_EQ(stringFromUTF8("Cocoa")->hash(), StringHasher::computeLiteralHashAndMaskTop8Bits("Cocoa"));
+    ASSERT_EQ(stringFromUTF8("Cappuccino")->hash(), StringHasher::computeLiteralHashAndMaskTop8Bits("Cappuccino"));
+}
+
+TEST(WTF, StringImplEmpty)
+{
+    ASSERT_FALSE(StringImpl::empty()->length());
+}
+
 } // namespace TestWebKitAPI