diff options
Diffstat (limited to 'Tools/TestWebKitAPI/Tests/WTF')
52 files changed, 10008 insertions, 471 deletions
diff --git a/Tools/TestWebKitAPI/Tests/WTF/AtomicString.cpp b/Tools/TestWebKitAPI/Tests/WTF/AtomicString.cpp index 9df71ce44..de962ec42 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/AtomicString.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/AtomicString.cpp @@ -39,7 +39,6 @@ TEST(WTF, AtomicStringCreationFromLiteral) const char* programmaticStringData = "Explicit Size Literal"; AtomicString programmaticString(programmaticStringData, strlen(programmaticStringData), AtomicString::ConstructFromLiteral); ASSERT_EQ(strlen(programmaticStringData), programmaticString.length()); - ASSERT_TRUE(programmaticStringData == programmaticStringData); ASSERT_TRUE(programmaticString.string().is8Bit()); ASSERT_EQ(programmaticStringData, reinterpret_cast<const char*>(programmaticString.string().characters8())); } @@ -54,4 +53,12 @@ TEST(WTF, AtomicStringCreationFromLiteralUniqueness) ASSERT_EQ(string1.impl(), string3.impl()); } +TEST(WTF, AtomicStringExistingHash) +{ + AtomicString string1("Template Literal", AtomicString::ConstructFromLiteral); + ASSERT_EQ(string1.existingHash(), string1.impl()->existingHash()); + AtomicString string2; + ASSERT_EQ(string2.existingHash(), 0u); +} + } // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/BloomFilter.cpp b/Tools/TestWebKitAPI/Tests/WTF/BloomFilter.cpp new file mode 100644 index 000000000..802165211 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/BloomFilter.cpp @@ -0,0 +1,250 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <wtf/BloomFilter.h> +#include <wtf/RandomNumber.h> +#include <wtf/SHA1.h> + +namespace TestWebKitAPI { + +static Vector<unsigned> generateRandomHashes(size_t hashCount) +{ + Vector<unsigned> hashes; + for (unsigned i = 0; i < hashCount; ++i) + hashes.append(static_cast<unsigned>(randomNumber() * std::numeric_limits<unsigned>::max())); + return hashes; +} + +static Vector<SHA1::Digest> generateRandomDigests(size_t hashCount) +{ + Vector<SHA1::Digest> hashes; + SHA1 sha1; + for (unsigned i = 0; i < hashCount; ++i) { + double random = randomNumber(); + sha1.addBytes(reinterpret_cast<uint8_t*>(&random), sizeof(double)); + SHA1::Digest digest; + sha1.computeHash(digest); + hashes.append(digest); + } + return hashes; +} + +TEST(WTF_BloomFilter, Basic) +{ + const unsigned hashCount = 1000; + auto hashes = generateRandomHashes(hashCount); + + BloomFilter<16> filter; + for (auto hash : hashes) + filter.add(hash); + + for (auto hash : hashes) + EXPECT_TRUE(filter.mayContain(hash)); + + auto moreHashes = generateRandomHashes(hashCount); + unsigned mayContainCount = 0; + for (auto hash : moreHashes) + mayContainCount += filter.mayContain(hash) ? 1 : 0; + // False positive rate is ~0.09% so this should always be true. + EXPECT_TRUE(mayContainCount < hashCount / 10); + + for (auto hash : moreHashes) + filter.add(hash); + + for (auto hash : hashes) + EXPECT_TRUE(filter.mayContain(hash)); + for (auto hash : moreHashes) + EXPECT_TRUE(filter.mayContain(hash)); +} + +TEST(WTF_BloomFilter, BasicDigest) +{ + const unsigned hashCount = 1000; + auto hashes = generateRandomDigests(hashCount); + + BloomFilter<20> filter; + for (auto hash : hashes) + filter.add(hash); + + for (auto hash : hashes) + EXPECT_TRUE(filter.mayContain(hash)); + + auto moreHashes = generateRandomDigests(hashCount); + unsigned mayContainCount = 0; + for (auto hash : moreHashes) + mayContainCount += filter.mayContain(hash) ? 1 : 0; + // False positive rate is ~0.000004% so this should always be true. + EXPECT_TRUE(mayContainCount < hashCount / 10); + + for (auto hash : moreHashes) + filter.add(hash); + + for (auto hash : hashes) + EXPECT_TRUE(filter.mayContain(hash)); + for (auto hash : moreHashes) + EXPECT_TRUE(filter.mayContain(hash)); +} + +TEST(WTF_BloomFilter, BasicCounting) +{ + const unsigned hashCount = 1000; + auto hashes = generateRandomHashes(hashCount); + + CountingBloomFilter<16> filter; + for (auto hash : hashes) + filter.add(hash); + + for (auto hash : hashes) + EXPECT_TRUE(filter.mayContain(hash)); + + for (auto hash : hashes) + filter.add(hash); + + for (auto hash : hashes) + EXPECT_TRUE(filter.mayContain(hash)); + + for (auto hash : hashes) + filter.remove(hash); + + for (auto hash : hashes) + EXPECT_TRUE(filter.mayContain(hash)); + + auto moreHashes = generateRandomHashes(hashCount); + unsigned mayContainCount = 0; + for (auto hash : moreHashes) + mayContainCount += filter.mayContain(hash) ? 1 : 0; + // False positive rate is ~0.09% so this should always be true. + EXPECT_TRUE(mayContainCount < hashCount / 10); + + for (auto hash : moreHashes) + filter.add(hash); + for (auto hash : hashes) + filter.remove(hash); + + for (auto hash : moreHashes) + EXPECT_TRUE(filter.mayContain(hash)); + + for (auto hash : moreHashes) + filter.remove(hash); + + for (auto hash : hashes) + EXPECT_TRUE(!filter.mayContain(hash)); + for (auto hash : moreHashes) + EXPECT_TRUE(!filter.mayContain(hash)); +} + +TEST(WTF_BloomFilter, Clear) +{ + const unsigned hashCount = 1000; + auto hashes = generateRandomHashes(hashCount); + + BloomFilter<16> filter; + for (auto hash : hashes) + filter.add(hash); + + filter.clear(); + + for (auto hash : hashes) + EXPECT_TRUE(!filter.mayContain(hash)); +} + +TEST(WTF_BloomFilter, ClearCounting) +{ + const unsigned hashCount = 1000; + auto hashes = generateRandomHashes(hashCount); + + CountingBloomFilter<16> filter; + for (auto hash : hashes) + filter.add(hash); + for (auto hash : hashes) + filter.add(hash); + + filter.clear(); + + for (auto hash : hashes) + EXPECT_TRUE(!filter.mayContain(hash)); +} + +TEST(WTF_BloomFilter, CountingOverflow) +{ + const unsigned hashCount = 1000; + auto hashes = generateRandomHashes(hashCount); + + CountingBloomFilter<16> filter; + for (auto hash : hashes) + filter.add(hash); + + for (unsigned i = 0; i < filter.maximumCount() + 100; ++i) + filter.add(hashes[0]); + + for (auto hash : hashes) + EXPECT_TRUE(filter.mayContain(hash)); + + for (auto hash : hashes) + filter.remove(hash); + + unsigned mayContainCount = 0; + for (auto hash : hashes) { + if (hash == hashes[0]) + EXPECT_TRUE(filter.mayContain(hash)); + else + mayContainCount += filter.mayContain(hash) ? 1 : 0; + } + // False positive rate should be very low. + EXPECT_TRUE(mayContainCount < hashCount / 100); + + for (unsigned i = 0; i < filter.maximumCount() + 100; ++i) + filter.remove(hashes[0]); + + // The bucket has overflowed and is stuck. + EXPECT_TRUE(filter.mayContain(hashes[0])); +} + +TEST(WTF_BloomFilter, Combine) +{ + const unsigned hashCount = 1000; + auto hashes = generateRandomHashes(hashCount); + + BloomFilter<16> filter; + for (auto hash : hashes) + filter.add(hash); + + auto moreHashes = generateRandomHashes(hashCount); + + BloomFilter<16> anotherFilter; + for (auto hash : moreHashes) + anotherFilter.add(hash); + + filter.add(anotherFilter); + + for (auto hash : hashes) + EXPECT_TRUE(filter.mayContain(hash)); + for (auto hash : moreHashes) + EXPECT_TRUE(filter.mayContain(hash)); +} + +} diff --git a/Tools/TestWebKitAPI/Tests/WTF/CheckedArithmeticOperations.cpp b/Tools/TestWebKitAPI/Tests/WTF/CheckedArithmeticOperations.cpp index 77b8ff458..d6b548316 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/CheckedArithmeticOperations.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/CheckedArithmeticOperations.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 Apple Inc. All rights reserved. + * Copyright (C) 2011, 2015 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -28,117 +28,397 @@ namespace TestWebKitAPI { -#define CheckedArithmeticTest(type, coerceLiteral, MixedSignednessTest) \ +class OverflowCrashLogger { +protected: + void overflowed() + { + m_overflowCount++; + } + + void clearOverflow() + { + m_overflowCount = 0; + } + + static void crash() + { + s_didCrash = true; + } + +public: + void reset() + { + m_overflowCount = 0; + s_didCrash = false; + } + + bool hasOverflowed() const { return m_overflowCount > 0; } + int overflowCount() const { return m_overflowCount; } + + bool didCrash() const { return s_didCrash; } + +private: + int m_overflowCount { 0 }; + static bool s_didCrash; +}; + +bool OverflowCrashLogger::s_didCrash = false; + +template <typename type> +static void resetOverflow(Checked<type, OverflowCrashLogger>& value) +{ + value.reset(); + value = 100; + value *= std::numeric_limits<type>::max(); +} + +#define CheckedArithmeticTest(type, Coercer, MixedSignednessTester) \ TEST(WTF, Checked_##type) \ { \ - Checked<type, RecordOverflow> value; \ - EXPECT_EQ(coerceLiteral(0), value.unsafeGet()); \ - EXPECT_EQ(std::numeric_limits<type>::max(), (value + std::numeric_limits<type>::max()).unsafeGet()); \ - EXPECT_EQ(std::numeric_limits<type>::max(), (std::numeric_limits<type>::max() + value).unsafeGet()); \ - EXPECT_EQ(std::numeric_limits<type>::min(), (value + std::numeric_limits<type>::min()).unsafeGet()); \ - EXPECT_EQ(std::numeric_limits<type>::min(), (std::numeric_limits<type>::min() + value).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), (value * coerceLiteral(0)).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), (coerceLiteral(0) * value).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), (value * value).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), (value - coerceLiteral(0)).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), (coerceLiteral(0) - value).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), (value - value).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), (value++).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(1), (value--).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(1), (++value).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), (--value).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(10), (value += coerceLiteral(10)).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(10), value.unsafeGet()); \ - EXPECT_EQ(coerceLiteral(100), (value *= coerceLiteral(10)).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(100), value.unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), (value -= coerceLiteral(100)).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), value.unsafeGet()); \ - value = 10; \ - EXPECT_EQ(coerceLiteral(10), value.unsafeGet()); \ - EXPECT_EQ(coerceLiteral(0), (value - coerceLiteral(10)).unsafeGet()); \ - EXPECT_EQ(coerceLiteral(10), value.unsafeGet()); \ - value = std::numeric_limits<type>::min(); \ - EXPECT_EQ(true, (Checked<type, RecordOverflow>(value - coerceLiteral(1))).hasOverflowed()); \ - EXPECT_EQ(true, !((value--).hasOverflowed())); \ - EXPECT_EQ(true, value.hasOverflowed()); \ - value = std::numeric_limits<type>::max(); \ - EXPECT_EQ(true, !value.hasOverflowed()); \ - EXPECT_EQ(true, (Checked<type, RecordOverflow>(value + coerceLiteral(1))).hasOverflowed()); \ - EXPECT_EQ(true, !(value++).hasOverflowed()); \ - EXPECT_EQ(true, value.hasOverflowed()); \ - value = std::numeric_limits<type>::max(); \ - EXPECT_EQ(true, (value += coerceLiteral(1)).hasOverflowed()); \ - EXPECT_EQ(true, value.hasOverflowed()); \ - value = 10; \ - type _value = 0; \ - EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(0)).safeGet(_value)); \ - _value = 0; \ - EXPECT_EQ(true, CheckedState::DidNotOverflow == (Checked<type, RecordOverflow>(0) * value).safeGet(_value)); \ - _value = 0; \ - EXPECT_EQ(true, CheckedState::DidOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); \ - _value = 0; \ - EXPECT_EQ(true, CheckedState::DidOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * value).safeGet(_value)); \ - value = 0; \ - _value = 0; \ - EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); \ - _value = 0; \ - EXPECT_EQ(true, CheckedState::DidNotOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * value).safeGet(_value)); \ - value = 1; \ - _value = 0; \ - EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); \ - _value = 0; \ - EXPECT_EQ(true, CheckedState::DidNotOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * value).safeGet(_value)); \ - _value = 0; \ - value = 0; \ - EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); \ - _value = 0; \ - EXPECT_EQ(true, CheckedState::DidNotOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * (type)0).safeGet(_value)); \ - _value = 0; \ - value = 1; \ - EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); \ - _value = 0; \ - EXPECT_EQ(true, CheckedState::DidNotOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * (type)1).safeGet(_value)); \ - _value = 0; \ - value = 2; \ - EXPECT_EQ(true, CheckedState::DidOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); \ - _value = 0; \ - EXPECT_EQ(true, CheckedState::DidOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * (type)2).safeGet(_value)); \ - value = 10; \ - EXPECT_EQ(true, (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).hasOverflowed()); \ - MixedSignednessTest(EXPECT_EQ(coerceLiteral(0), (value + -10).unsafeGet())); \ - MixedSignednessTest(EXPECT_EQ(0U, (value - 10U).unsafeGet())); \ - MixedSignednessTest(EXPECT_EQ(coerceLiteral(0), (-10 + value).unsafeGet())); \ - MixedSignednessTest(EXPECT_EQ(0U, (10U - value).unsafeGet())); \ - value = std::numeric_limits<type>::min(); \ - MixedSignednessTest(EXPECT_EQ(true, (Checked<type, RecordOverflow>(value - 1)).hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, !(value--).hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, value.hasOverflowed())); \ - value = std::numeric_limits<type>::max(); \ - MixedSignednessTest(EXPECT_EQ(true, !value.hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, (Checked<type, RecordOverflow>(value + 1)).hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, !(value++).hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, value.hasOverflowed())); \ - value = std::numeric_limits<type>::max(); \ - MixedSignednessTest(EXPECT_EQ(true, (value += 1).hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, value.hasOverflowed())); \ - value = std::numeric_limits<type>::min(); \ - MixedSignednessTest(EXPECT_EQ(true, (value - 1U).hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, !(value--).hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, value.hasOverflowed())); \ - value = std::numeric_limits<type>::max(); \ - MixedSignednessTest(EXPECT_EQ(true, !value.hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, (Checked<type, RecordOverflow>(value + 1U)).hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, !(value++).hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, value.hasOverflowed())); \ - value = std::numeric_limits<type>::max(); \ - MixedSignednessTest(EXPECT_EQ(true, (value += 1U).hasOverflowed())); \ - MixedSignednessTest(EXPECT_EQ(true, value.hasOverflowed())); \ + typedef Coercer<type> CoercerType; \ + typedef MixedSignednessTester<type, CoercerType> MixedSignednessTesterType; \ + CheckedArithmeticTester<type, CoercerType, MixedSignednessTesterType>::run(); \ } + +#define coerceLiteral(x) Coercer::coerce(x) + +template <typename type, typename Coercer, typename MixedSignednessTester> +class CheckedArithmeticTester { +public: + static void run() + { + Checked<type, RecordOverflow> value; + EXPECT_EQ(coerceLiteral(0), value.unsafeGet()); + EXPECT_EQ(std::numeric_limits<type>::max(), (value + std::numeric_limits<type>::max()).unsafeGet()); + EXPECT_EQ(std::numeric_limits<type>::max(), (std::numeric_limits<type>::max() + value).unsafeGet()); + EXPECT_EQ(std::numeric_limits<type>::min(), (value + std::numeric_limits<type>::min()).unsafeGet()); + EXPECT_EQ(std::numeric_limits<type>::min(), (std::numeric_limits<type>::min() + value).unsafeGet()); + + EXPECT_EQ(coerceLiteral(0), (value * coerceLiteral(0)).unsafeGet()); + EXPECT_EQ(coerceLiteral(0), (coerceLiteral(0) * value).unsafeGet()); + EXPECT_EQ(coerceLiteral(0), (value * value).unsafeGet()); + EXPECT_EQ(coerceLiteral(0), (value - coerceLiteral(0)).unsafeGet()); + EXPECT_EQ(coerceLiteral(0), (coerceLiteral(0) - value).unsafeGet()); + EXPECT_EQ(coerceLiteral(0), (value - value).unsafeGet()); + EXPECT_EQ(coerceLiteral(0), (value++).unsafeGet()); + EXPECT_EQ(coerceLiteral(1), (value--).unsafeGet()); + EXPECT_EQ(coerceLiteral(1), (++value).unsafeGet()); + EXPECT_EQ(coerceLiteral(0), (--value).unsafeGet()); + EXPECT_EQ(coerceLiteral(10), (value += coerceLiteral(10)).unsafeGet()); + EXPECT_EQ(coerceLiteral(10), value.unsafeGet()); + EXPECT_EQ(coerceLiteral(100), (value *= coerceLiteral(10)).unsafeGet()); + EXPECT_EQ(coerceLiteral(100), value.unsafeGet()); + EXPECT_EQ(coerceLiteral(0), (value -= coerceLiteral(100)).unsafeGet()); + EXPECT_EQ(coerceLiteral(0), value.unsafeGet()); + value = 10; + EXPECT_EQ(coerceLiteral(10), value.unsafeGet()); + EXPECT_EQ(coerceLiteral(0), (value - coerceLiteral(10)).unsafeGet()); + EXPECT_EQ(coerceLiteral(10), value.unsafeGet()); + + value = std::numeric_limits<type>::min(); + EXPECT_EQ(true, (Checked<type, RecordOverflow>(value - coerceLiteral(1))).hasOverflowed()); + EXPECT_EQ(true, !((value--).hasOverflowed())); + EXPECT_EQ(true, value.hasOverflowed()); + value = std::numeric_limits<type>::max(); + EXPECT_EQ(true, !value.hasOverflowed()); + EXPECT_EQ(true, (Checked<type, RecordOverflow>(value + coerceLiteral(1))).hasOverflowed()); + EXPECT_EQ(true, !(value++).hasOverflowed()); + EXPECT_EQ(true, value.hasOverflowed()); + value = std::numeric_limits<type>::max(); + EXPECT_EQ(true, (value += coerceLiteral(1)).hasOverflowed()); + EXPECT_EQ(true, value.hasOverflowed()); + + value = 10; + type _value = 0; + EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(0)).safeGet(_value)); + _value = 0; + EXPECT_EQ(true, CheckedState::DidNotOverflow == (Checked<type, RecordOverflow>(0) * value).safeGet(_value)); + _value = 0; + EXPECT_EQ(true, CheckedState::DidOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); + _value = 0; + EXPECT_EQ(true, CheckedState::DidOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * value).safeGet(_value)); + value = 0; + _value = 0; + EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); + _value = 0; + EXPECT_EQ(true, CheckedState::DidNotOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * value).safeGet(_value)); + value = 1; + _value = 0; + EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); + _value = 0; + EXPECT_EQ(true, CheckedState::DidNotOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * value).safeGet(_value)); + _value = 0; + value = 0; + EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); + _value = 0; + EXPECT_EQ(true, CheckedState::DidNotOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * (type)0).safeGet(_value)); + _value = 0; + value = 1; + EXPECT_EQ(true, CheckedState::DidNotOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); + _value = 0; + EXPECT_EQ(true, CheckedState::DidNotOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * (type)1).safeGet(_value)); + _value = 0; + value = 2; + EXPECT_EQ(true, CheckedState::DidOverflow == (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).safeGet(_value)); + _value = 0; + EXPECT_EQ(true, CheckedState::DidOverflow == (Checked<type, RecordOverflow>(std::numeric_limits<type>::max()) * (type)2).safeGet(_value)); + value = 10; + EXPECT_EQ(true, (value * Checked<type, RecordOverflow>(std::numeric_limits<type>::max())).hasOverflowed()); + + + Checked<type, OverflowCrashLogger> nvalue; // to hold a not overflowed value. + Checked<type, OverflowCrashLogger> ovalue; // to hold an overflowed value. + bool unused; + + _value = 75; + type _largeValue = 100; + type _smallValue = 50; + + value = _smallValue; + nvalue = _value; + ovalue = _value; + + // Make sure the OverflowCrashLogger is working as expected. + EXPECT_EQ(false, (ovalue.hasOverflowed())); + EXPECT_EQ(true, (resetOverflow(ovalue), ovalue.hasOverflowed())); + EXPECT_EQ(false, (resetOverflow(ovalue), ovalue.didCrash())); + EXPECT_EQ(true, (unused = (ovalue == ovalue), ovalue.didCrash())); + EXPECT_EQ(false, (resetOverflow(ovalue), ovalue.didCrash())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + EXPECT_EQ(false, nvalue.didCrash()); + + // Test operator== that should not overflow nor crash. + EXPECT_EQ(true, (nvalue == nvalue)); + EXPECT_EQ(true, (nvalue == Checked<type, OverflowCrashLogger>(_value))); + EXPECT_EQ(false, (nvalue == value)); + EXPECT_EQ(true, (nvalue == _value)); + EXPECT_EQ(false, (nvalue == Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max()))); + EXPECT_EQ(false, (nvalue == std::numeric_limits<type>::max())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + EXPECT_EQ(false, nvalue.didCrash()); + + // Test operator!= that should not overflow nor crash. + EXPECT_EQ(false, (nvalue != nvalue)); + EXPECT_EQ(false, (nvalue != Checked<type, OverflowCrashLogger>(_value))); + EXPECT_EQ(true, (nvalue != value)); + EXPECT_EQ(false, (nvalue != _value)); + EXPECT_EQ(true, (nvalue != Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max()))); + EXPECT_EQ(true, (nvalue != std::numeric_limits<type>::max())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + EXPECT_EQ(false, nvalue.didCrash()); + + // Test operator< that should not overflow nor crash. + EXPECT_EQ(false, (nvalue < nvalue)); + EXPECT_EQ(false, (nvalue < value)); + EXPECT_EQ(true, (nvalue < Checked<type, OverflowCrashLogger>(_largeValue))); + EXPECT_EQ(false, (nvalue < Checked<type, OverflowCrashLogger>(_value))); + EXPECT_EQ(false, (nvalue < Checked<type, OverflowCrashLogger>(_smallValue))); + EXPECT_EQ(true, (nvalue < _largeValue)); + EXPECT_EQ(false, (nvalue < _value)); + EXPECT_EQ(false, (nvalue < _smallValue)); + EXPECT_EQ(true, (nvalue < Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max()))); + EXPECT_EQ(true, (nvalue < std::numeric_limits<type>::max())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + EXPECT_EQ(false, nvalue.didCrash()); + + // Test operator<= that should not overflow nor crash. + EXPECT_EQ(true, (nvalue <= nvalue)); + EXPECT_EQ(false, (nvalue <= value)); + EXPECT_EQ(true, (nvalue <= Checked<type, OverflowCrashLogger>(_largeValue))); + EXPECT_EQ(true, (nvalue <= Checked<type, OverflowCrashLogger>(_value))); + EXPECT_EQ(false, (nvalue <= Checked<type, OverflowCrashLogger>(_smallValue))); + EXPECT_EQ(true, (nvalue <= _largeValue)); + EXPECT_EQ(true, (nvalue <= _value)); + EXPECT_EQ(false, (nvalue <= _smallValue)); + EXPECT_EQ(true, (nvalue <= Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max()))); + EXPECT_EQ(true, (nvalue <= std::numeric_limits<type>::max())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + EXPECT_EQ(false, nvalue.didCrash()); + + // Test operator> that should not overflow nor crash. + EXPECT_EQ(false, (nvalue > nvalue)); + EXPECT_EQ(true, (nvalue > value)); + EXPECT_EQ(false, (nvalue > Checked<type, OverflowCrashLogger>(_largeValue))); + EXPECT_EQ(false, (nvalue > Checked<type, OverflowCrashLogger>(_value))); + EXPECT_EQ(true, (nvalue > Checked<type, OverflowCrashLogger>(_smallValue))); + EXPECT_EQ(false, (nvalue > _largeValue)); + EXPECT_EQ(false, (nvalue > _value)); + EXPECT_EQ(true, (nvalue > _smallValue)); + EXPECT_EQ(false, (nvalue > Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max()))); + EXPECT_EQ(false, (nvalue > std::numeric_limits<type>::max())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + EXPECT_EQ(false, nvalue.didCrash()); + + // Test operator>= that should not overflow nor crash. + EXPECT_EQ(true, (nvalue >= nvalue)); + EXPECT_EQ(true, (nvalue >= value)); + EXPECT_EQ(false, (nvalue >= Checked<type, OverflowCrashLogger>(_largeValue))); + EXPECT_EQ(true, (nvalue >= Checked<type, OverflowCrashLogger>(_value))); + EXPECT_EQ(true, (nvalue >= Checked<type, OverflowCrashLogger>(_smallValue))); + EXPECT_EQ(false, (nvalue >= _largeValue)); + EXPECT_EQ(true, (nvalue >= _value)); + EXPECT_EQ(true, (nvalue >= _smallValue)); + EXPECT_EQ(false, (nvalue >= Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max()))); + EXPECT_EQ(false, (nvalue >= std::numeric_limits<type>::max())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + EXPECT_EQ(false, nvalue.didCrash()); + + // Test operator== with an overflowed value. + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue == ovalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue == Checked<type, OverflowCrashLogger>(_value)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue == value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue == _value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue == _value * std::numeric_limits<type>::max()), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue == Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max())), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue == std::numeric_limits<type>::max()), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue == nvalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (nvalue == ovalue), ovalue.didCrash())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + + // Test operator!= with an overflowed value. + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue != ovalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue != Checked<type, OverflowCrashLogger>(_value)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue != value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue != _value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue != _value * std::numeric_limits<type>::max()), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue != Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max())), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue != std::numeric_limits<type>::max()), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue != nvalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (nvalue != ovalue), ovalue.didCrash())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + + // Test operator< with an overflowed value. + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < ovalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < Checked<type, OverflowCrashLogger>(_largeValue)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < Checked<type, OverflowCrashLogger>(_value)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < Checked<type, OverflowCrashLogger>(_smallValue)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < _largeValue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < _value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < _smallValue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max())), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < std::numeric_limits<type>::max()), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue < nvalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (nvalue < ovalue), ovalue.didCrash())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + + // Test operator<= with an overflowed value. + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= ovalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= Checked<type, OverflowCrashLogger>(_largeValue)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= Checked<type, OverflowCrashLogger>(_value)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= Checked<type, OverflowCrashLogger>(_smallValue)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= _largeValue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= _value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= _smallValue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max())), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= std::numeric_limits<type>::max()), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue <= nvalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (nvalue <= ovalue), ovalue.didCrash())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + + // Test operator> with an overflowed value. + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > ovalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > Checked<type, OverflowCrashLogger>(_largeValue)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > Checked<type, OverflowCrashLogger>(_value)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > Checked<type, OverflowCrashLogger>(_smallValue)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > _largeValue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > _value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > _smallValue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max())), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > std::numeric_limits<type>::max()), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue > nvalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (nvalue > ovalue), ovalue.didCrash())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + + // Test operator>= with an overflowed value. + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= ovalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= Checked<type, OverflowCrashLogger>(_largeValue)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= Checked<type, OverflowCrashLogger>(_value)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= Checked<type, OverflowCrashLogger>(_smallValue)), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= _largeValue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= _value), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= _smallValue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= Checked<type, OverflowCrashLogger>(std::numeric_limits<type>::max())), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= std::numeric_limits<type>::max()), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (ovalue >= nvalue), ovalue.didCrash())); + EXPECT_EQ(true, (resetOverflow(ovalue), unused = (nvalue >= ovalue), ovalue.didCrash())); + + EXPECT_EQ(false, nvalue.hasOverflowed()); + + MixedSignednessTester::run(); + } +}; + +template <typename type, typename Coercer> +class AllowMixedSignednessTest { +public: + static void run() + { + Checked<type, RecordOverflow> value; + value = 10; + + EXPECT_EQ(coerceLiteral(0), (value + -10).unsafeGet()); + EXPECT_EQ(0U, (value - 10U).unsafeGet()); + EXPECT_EQ(coerceLiteral(0), (-10 + value).unsafeGet()); + EXPECT_EQ(0U, (10U - value).unsafeGet()); + value = std::numeric_limits<type>::min(); + EXPECT_EQ(true, (Checked<type, RecordOverflow>(value - 1)).hasOverflowed()); + EXPECT_EQ(true, !(value--).hasOverflowed()); + EXPECT_EQ(true, value.hasOverflowed()); + value = std::numeric_limits<type>::max(); + EXPECT_EQ(true, !value.hasOverflowed()); + EXPECT_EQ(true, (Checked<type, RecordOverflow>(value + 1)).hasOverflowed()); + EXPECT_EQ(true, !(value++).hasOverflowed()); + EXPECT_EQ(true, value.hasOverflowed()); + value = std::numeric_limits<type>::max(); + EXPECT_EQ(true, (value += 1).hasOverflowed()); + EXPECT_EQ(true, value.hasOverflowed()); + value = std::numeric_limits<type>::min(); + EXPECT_EQ(true, (value - 1U).hasOverflowed()); + EXPECT_EQ(true, !(value--).hasOverflowed()); + EXPECT_EQ(true, value.hasOverflowed()); + value = std::numeric_limits<type>::max(); + EXPECT_EQ(true, !value.hasOverflowed()); + EXPECT_EQ(true, (Checked<type, RecordOverflow>(value + 1U)).hasOverflowed()); + EXPECT_EQ(true, !(value++).hasOverflowed()); + EXPECT_EQ(true, value.hasOverflowed()); + value = std::numeric_limits<type>::max(); + EXPECT_EQ(true, (value += 1U).hasOverflowed()); + EXPECT_EQ(true, value.hasOverflowed()); + } +}; + +template <typename type, typename Coercer> +class IgnoreMixedSignednessTest { +public: + static void run() { } +}; + +template <typename type> class CoerceLiteralToUnsigned { +public: + static unsigned coerce(type x) { return static_cast<unsigned>(x); } +}; + +template <typename type> class CoerceLiteralNop { +public: + static type coerce(type x) { return x; } +}; -#define CoerceLiteralToUnsigned(x) x##U -#define CoerceLiteralNop(x) x -#define AllowMixedSignednessTest(x) x -#define IgnoreMixedSignednessTest(x) CheckedArithmeticTest(int8_t, CoerceLiteralNop, IgnoreMixedSignednessTest) CheckedArithmeticTest(int16_t, CoerceLiteralNop, IgnoreMixedSignednessTest) CheckedArithmeticTest(int32_t, CoerceLiteralNop, AllowMixedSignednessTest) @@ -146,4 +426,62 @@ CheckedArithmeticTest(uint32_t, CoerceLiteralToUnsigned, AllowMixedSignednessTes CheckedArithmeticTest(int64_t, CoerceLiteralNop, IgnoreMixedSignednessTest) CheckedArithmeticTest(uint64_t, CoerceLiteralToUnsigned, IgnoreMixedSignednessTest) +TEST(CheckedArithmeticTest, IsInBounds) +{ + // bigger precision, signed, signed + EXPECT_TRUE(WTF::isInBounds<int32_t>(std::numeric_limits<int16_t>::max())); + EXPECT_TRUE(WTF::isInBounds<int32_t>(std::numeric_limits<int16_t>::min())); + + // bigger precision, unsigned, signed + EXPECT_TRUE(WTF::isInBounds<uint32_t>(std::numeric_limits<int32_t>::max())); + EXPECT_FALSE(WTF::isInBounds<uint32_t>(std::numeric_limits<int16_t>::min())); + + EXPECT_FALSE(WTF::isInBounds<uint32_t>((int32_t)-1)); + EXPECT_FALSE(WTF::isInBounds<uint16_t>((int32_t)-1)); + EXPECT_FALSE(WTF::isInBounds<unsigned long>((int)-1)); + + EXPECT_TRUE(WTF::isInBounds<uint32_t>((int32_t)1)); + EXPECT_TRUE(WTF::isInBounds<uint32_t>((int16_t)1)); + EXPECT_TRUE(WTF::isInBounds<unsigned>((int)1)); + + EXPECT_TRUE(WTF::isInBounds<uint32_t>((int32_t)0)); + EXPECT_TRUE(WTF::isInBounds<uint16_t>((int32_t)0)); + EXPECT_TRUE(WTF::isInBounds<uint32_t>((int16_t)0)); + EXPECT_TRUE(WTF::isInBounds<unsigned>((int)0)); + + EXPECT_TRUE(WTF::isInBounds<uint32_t>(std::numeric_limits<int32_t>::max())); + EXPECT_TRUE(WTF::isInBounds<uint32_t>(std::numeric_limits<int16_t>::max())); + EXPECT_TRUE(WTF::isInBounds<unsigned>(std::numeric_limits<int>::max())); + + // bigger precision, signed, unsigned + EXPECT_TRUE(WTF::isInBounds<int32_t>(std::numeric_limits<uint16_t>::max())); + EXPECT_FALSE(WTF::isInBounds<int32_t>(std::numeric_limits<uint32_t>::max())); + EXPECT_TRUE(WTF::isInBounds<int32_t>((uint32_t)0)); + + // bigger precision, unsigned, unsigned + EXPECT_TRUE(WTF::isInBounds<uint32_t>(std::numeric_limits<uint16_t>::max())); + EXPECT_TRUE(WTF::isInBounds<uint32_t>(std::numeric_limits<uint16_t>::min())); + + // lower precision, signed signed + EXPECT_FALSE(WTF::isInBounds<int16_t>(std::numeric_limits<int32_t>::max())); + EXPECT_FALSE(WTF::isInBounds<int16_t>(std::numeric_limits<int32_t>::min())); + EXPECT_TRUE(WTF::isInBounds<int16_t>((int32_t)-1)); + EXPECT_TRUE(WTF::isInBounds<int16_t>((int32_t)0)); + EXPECT_TRUE(WTF::isInBounds<int16_t>((int32_t)1)); + // lower precision, unsigned, signed + EXPECT_FALSE(WTF::isInBounds<uint16_t>(std::numeric_limits<int32_t>::max())); + EXPECT_FALSE(WTF::isInBounds<uint16_t>(std::numeric_limits<int32_t>::min())); + EXPECT_FALSE(WTF::isInBounds<uint16_t>((int32_t)-1)); + EXPECT_TRUE(WTF::isInBounds<uint16_t>((int32_t)0)); + EXPECT_TRUE(WTF::isInBounds<uint16_t>((int32_t)1)); + // lower precision, signed, unsigned + EXPECT_FALSE(WTF::isInBounds<int16_t>(std::numeric_limits<uint32_t>::max())); + EXPECT_TRUE(WTF::isInBounds<int16_t>((uint32_t)0)); + EXPECT_TRUE(WTF::isInBounds<int16_t>((uint32_t)1)); + // lower precision, unsigned, unsigned + EXPECT_FALSE(WTF::isInBounds<uint16_t>(std::numeric_limits<uint32_t>::max())); + EXPECT_TRUE(WTF::isInBounds<uint16_t>((uint32_t)0)); + EXPECT_TRUE(WTF::isInBounds<uint16_t>((uint32_t)1)); +} + } // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/Condition.cpp b/Tools/TestWebKitAPI/Tests/WTF/Condition.cpp new file mode 100644 index 000000000..848527351 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/Condition.cpp @@ -0,0 +1,257 @@ +/* + * Copyright (C) 2015-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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include <mutex> +#include <thread> +#include <wtf/Condition.h> +#include <wtf/DataLog.h> +#include <wtf/Deque.h> +#include <wtf/Lock.h> +#include <wtf/StringPrintStream.h> +#include <wtf/Threading.h> +#include <wtf/Vector.h> + +using namespace WTF; + +namespace TestWebKitAPI { + +namespace { + +const bool verbose = false; + +enum NotifyStyle { + AlwaysNotifyOne, + TacticallyNotifyAll +}; + +template<typename Functor> +void wait(Condition& condition, std::unique_lock<Lock>& locker, const Functor& predicate, Seconds timeout) +{ + if (timeout == Seconds::infinity()) + condition.wait(locker, predicate); + else { + // This tests timeouts in the sense that it verifies that we can call wait() again after a + // timeout happened. That's a non-trivial piece of functionality since upon timeout the + // ParkingLot has to remove us from the queue. + while (!predicate()) + condition.waitFor(locker, timeout, predicate); + } +} + +void notify(NotifyStyle notifyStyle, Condition& condition, bool shouldNotify) +{ + switch (notifyStyle) { + case AlwaysNotifyOne: + condition.notifyOne(); + break; + case TacticallyNotifyAll: + if (shouldNotify) + condition.notifyAll(); + break; + } +} + +void runTest( + unsigned numProducers, + unsigned numConsumers, + unsigned maxQueueSize, + unsigned numMessagesPerProducer, + NotifyStyle notifyStyle, + Seconds timeout = Seconds::infinity(), + Seconds delay = 0_s) +{ + Deque<unsigned> queue; + bool shouldContinue = true; + Lock lock; + Condition emptyCondition; + Condition fullCondition; + + Vector<ThreadIdentifier> consumerThreads; + Vector<ThreadIdentifier> producerThreads; + + Vector<unsigned> received; + Lock receivedLock; + + for (unsigned i = numConsumers; i--;) { + ThreadIdentifier threadIdentifier = createThread( + "Consumer thread", + [&] () { + for (;;) { + unsigned result; + unsigned shouldNotify = false; + { + std::unique_lock<Lock> locker(lock); + wait( + emptyCondition, locker, + [&] () { + if (verbose) + dataLog(toString(currentThread(), ": Checking consumption predicate with shouldContinue = ", shouldContinue, ", queue.size() == ", queue.size(), "\n")); + return !shouldContinue || !queue.isEmpty(); + }, + timeout); + if (!shouldContinue && queue.isEmpty()) + return; + shouldNotify = queue.size() == maxQueueSize; + result = queue.takeFirst(); + } + notify(notifyStyle, fullCondition, shouldNotify); + + { + std::lock_guard<Lock> locker(receivedLock); + received.append(result); + } + } + }); + consumerThreads.append(threadIdentifier); + } + + sleep(delay); + + for (unsigned i = numProducers; i--;) { + ThreadIdentifier threadIdentifier = createThread( + "Producer Thread", + [&] () { + for (unsigned i = 0; i < numMessagesPerProducer; ++i) { + bool shouldNotify = false; + { + std::unique_lock<Lock> locker(lock); + wait( + fullCondition, locker, + [&] () { + if (verbose) + dataLog(toString(currentThread(), ": Checking production predicate with shouldContinue = ", shouldContinue, ", queue.size() == ", queue.size(), "\n")); + return queue.size() < maxQueueSize; + }, + timeout); + shouldNotify = queue.isEmpty(); + queue.append(i); + } + notify(notifyStyle, emptyCondition, shouldNotify); + } + }); + producerThreads.append(threadIdentifier); + } + + for (ThreadIdentifier threadIdentifier : producerThreads) + waitForThreadCompletion(threadIdentifier); + + { + std::lock_guard<Lock> locker(lock); + shouldContinue = false; + } + emptyCondition.notifyAll(); + + for (ThreadIdentifier threadIdentifier : consumerThreads) + waitForThreadCompletion(threadIdentifier); + + EXPECT_EQ(numProducers * numMessagesPerProducer, received.size()); + std::sort(received.begin(), received.end()); + for (unsigned messageIndex = 0; messageIndex < numMessagesPerProducer; ++messageIndex) { + for (unsigned producerIndex = 0; producerIndex < numProducers; ++producerIndex) + EXPECT_EQ(messageIndex, received[messageIndex * numProducers + producerIndex]); + } +} + +} // anonymous namespace + +TEST(WTF_Condition, OneProducerOneConsumerOneSlot) +{ + runTest(1, 1, 1, 100000, TacticallyNotifyAll); +} + +TEST(WTF_Condition, OneProducerOneConsumerOneSlotTimeout) +{ + runTest( + 1, 1, 1, 100000, TacticallyNotifyAll, + Seconds::fromMilliseconds(10), + Seconds(1)); +} + +TEST(WTF_Condition, OneProducerOneConsumerHundredSlots) +{ + runTest(1, 1, 100, 1000000, TacticallyNotifyAll); +} + +TEST(WTF_Condition, TenProducersOneConsumerOneSlot) +{ + runTest(10, 1, 1, 10000, TacticallyNotifyAll); +} + +TEST(WTF_Condition, TenProducersOneConsumerHundredSlotsNotifyAll) +{ + runTest(10, 1, 100, 10000, TacticallyNotifyAll); +} + +TEST(WTF_Condition, TenProducersOneConsumerHundredSlotsNotifyOne) +{ + runTest(10, 1, 100, 10000, AlwaysNotifyOne); +} + +TEST(WTF_Condition, OneProducerTenConsumersOneSlot) +{ + runTest(1, 10, 1, 10000, TacticallyNotifyAll); +} + +TEST(WTF_Condition, OneProducerTenConsumersHundredSlotsNotifyAll) +{ + runTest(1, 10, 100, 100000, TacticallyNotifyAll); +} + +TEST(WTF_Condition, OneProducerTenConsumersHundredSlotsNotifyOne) +{ + runTest(1, 10, 100, 100000, AlwaysNotifyOne); +} + +TEST(WTF_Condition, TenProducersTenConsumersOneSlot) +{ + runTest(10, 10, 1, 50000, TacticallyNotifyAll); +} + +TEST(WTF_Condition, TenProducersTenConsumersHundredSlotsNotifyAll) +{ + runTest(10, 10, 100, 50000, TacticallyNotifyAll); +} + +TEST(WTF_Condition, TenProducersTenConsumersHundredSlotsNotifyOne) +{ + runTest(10, 10, 100, 50000, AlwaysNotifyOne); +} + +TEST(WTF_Condition, TimeoutTimesOut) +{ + Lock lock; + Condition condition; + + lock.lock(); + bool result = condition.waitFor( + lock, Seconds::fromMilliseconds(10), [] () -> bool { return false; }); + lock.unlock(); + + EXPECT_FALSE(result); +} + +} // namespace TestWebKitAPI + diff --git a/Tools/TestWebKitAPI/Tests/WTF/Consume.cpp b/Tools/TestWebKitAPI/Tests/WTF/Consume.cpp new file mode 100644 index 000000000..e1a5d7a07 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/Consume.cpp @@ -0,0 +1,141 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <thread> +#include <wtf/Atomics.h> + +template <typename T> +NEVER_INLINE auto testConsume(const T* location) +{ + WTF::compilerFence(); // Paranoid testing. + auto ret = WTF::consumeLoad(location); + WTF::compilerFence(); // Paranoid testing. + return ret; +} + +namespace TestWebKitAPI { + +TEST(WTF, Consumei8) +{ + uint8_t i8 = 42; + auto i8_consumed = testConsume(&i8); + ASSERT_EQ(i8_consumed.value, 42u); + ASSERT_EQ(i8_consumed.dependency, 0u); +} + +TEST(WTF, Consumei16) +{ + uint16_t i16 = 42; + auto i16_consumed = testConsume(&i16); + ASSERT_EQ(i16_consumed.value, 42u); + ASSERT_EQ(i16_consumed.dependency, 0u); +} + +TEST(WTF, Consumei32) +{ + uint32_t i32 = 42; + auto i32_consumed = testConsume(&i32); + ASSERT_EQ(i32_consumed.value, 42u); + ASSERT_EQ(i32_consumed.dependency, 0u); +} + +TEST(WTF, Consumei64) +{ + uint64_t i64 = 42; + auto i64_consumed = testConsume(&i64); + ASSERT_EQ(i64_consumed.value, 42u); + ASSERT_EQ(i64_consumed.dependency, 0u); +} + +TEST(WTF, Consumef32) +{ + float f32 = 42.f; + auto f32_consumed = testConsume(&f32); + ASSERT_EQ(f32_consumed.value, 42.f); + ASSERT_EQ(f32_consumed.dependency, 0u); +} + +TEST(WTF, Consumef64) +{ + double f64 = 42.; + auto f64_consumed = testConsume(&f64); + ASSERT_EQ(f64_consumed.value, 42.); + ASSERT_EQ(f64_consumed.dependency, 0u); +} + +static int* global; + +TEST(WTF, ConsumeGlobalPtr) +{ + auto* ptr = &global; + auto ptr_consumed = testConsume(&ptr); + ASSERT_EQ(ptr_consumed.value, &global); + ASSERT_EQ(ptr_consumed.dependency, 0u); +} + +static int* globalArray[128]; + +TEST(WTF, ConsumeGlobalArrayPtr) +{ + auto* ptr = &globalArray[64]; + auto ptr_consumed = testConsume(&ptr); + ASSERT_EQ(ptr_consumed.value, &globalArray[64]); + ASSERT_EQ(ptr_consumed.dependency, 0u); +} + +TEST(WTF, ConsumeStackPtr) +{ + char* hello = nullptr; + auto* stack = &hello; + auto stack_consumed = testConsume(&stack); + ASSERT_EQ(stack_consumed.value, &hello); + ASSERT_EQ(stack_consumed.dependency, 0u); +} + +TEST(WTF, ConsumeWithThread) +{ + bool ready = false; + constexpr size_t num = 1024; + uint32_t* vec = new uint32_t[num]; + std::thread t([&]() { + for (size_t i = 0; i != num; ++i) + vec[i] = i * 2; + WTF::storeStoreFence(); + ready = true; + }); + do { + auto stack_consumed = testConsume(&ready); + if (stack_consumed.value) { + for (size_t i = 0; i != num; ++i) + ASSERT_EQ(vec[i + stack_consumed.dependency], i * 2); + break; + } + } while (true); + t.join(); + delete[] vec; +} +} diff --git a/Tools/TestWebKitAPI/Tests/WTF/CrossThreadTask.cpp b/Tools/TestWebKitAPI/Tests/WTF/CrossThreadTask.cpp new file mode 100644 index 000000000..52c0bcd41 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/CrossThreadTask.cpp @@ -0,0 +1,150 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <wtf/CrossThreadTask.h> +#include <wtf/HashCountedSet.h> +#include <wtf/text/StringBuilder.h> +#include <wtf/text/StringHash.h> + +namespace TestWebKitAPI { + +static size_t totalDestructorCalls; +static size_t totalIsolatedCopyCalls; + +static HashCountedSet<String> defaultConstructorSet; +static HashCountedSet<String> nameConstructorSet; +static HashCountedSet<String> copyConstructorSet; +static HashCountedSet<String> moveConstructorSet; + +struct LifetimeLogger { + LifetimeLogger() + { + defaultConstructorSet.add(fullName()); + } + + LifetimeLogger(const char* inputName) + : name(*inputName) + { + nameConstructorSet.add(fullName()); + } + + LifetimeLogger(const LifetimeLogger& other) + : name(other.name) + , copyGeneration(other.copyGeneration + 1) + , moveGeneration(other.moveGeneration) + { + copyConstructorSet.add(fullName()); + } + + LifetimeLogger(LifetimeLogger&& other) + : name(other.name) + , copyGeneration(other.copyGeneration) + , moveGeneration(other.moveGeneration + 1) + { + moveConstructorSet.add(fullName()); + } + + ~LifetimeLogger() + { + ++totalDestructorCalls; + } + + LifetimeLogger isolatedCopy() const + { + ++totalIsolatedCopyCalls; + return LifetimeLogger(*this); + } + + String fullName() + { + StringBuilder builder; + builder.append(&name); + builder.append("-"); + builder.append(String::number(copyGeneration)); + builder.append("-"); + builder.append(String::number(moveGeneration)); + + return builder.toString(); + } + + const char& name { *"<default>" }; + int copyGeneration { 0 }; + int moveGeneration { 0 }; +}; + +void testFunction(const LifetimeLogger&, const LifetimeLogger&, const LifetimeLogger&) +{ + // Do nothing - Just need to check the side effects of the arguments getting in here. +} + +TEST(WTF_CrossThreadTask, Basic) +{ + { + LifetimeLogger logger1; + LifetimeLogger logger2(logger1); + LifetimeLogger logger3("logger"); + + auto task = createCrossThreadTask(testFunction, logger1, logger2, logger3); + task.performTask(); + } + + ASSERT_EQ(1u, defaultConstructorSet.size()); + ASSERT_EQ(1u, defaultConstructorSet.count("<default>-0-0")); + + ASSERT_EQ(1u, nameConstructorSet.size()); + ASSERT_EQ(1u, nameConstructorSet.count("logger-0-0")); + + ASSERT_EQ(3u, copyConstructorSet.size()); + ASSERT_EQ(1u, copyConstructorSet.count("logger-1-0")); + ASSERT_EQ(2u, copyConstructorSet.count("<default>-1-0")); + ASSERT_EQ(1u, copyConstructorSet.count("<default>-2-0")); + +#if !COMPILER(MSVC) + ASSERT_EQ(6u, moveConstructorSet.size()); +#else + // The number of times the move constructor is called is different on Windows in this test. + // This seems to be caused by differences in MSVC's implementation of lambdas or std functions like std::make_tuple. + ASSERT_EQ(9u, moveConstructorSet.size()); +#endif + ASSERT_EQ(1u, moveConstructorSet.count("logger-1-1")); + ASSERT_EQ(1u, moveConstructorSet.count("logger-1-2")); + ASSERT_EQ(1u, moveConstructorSet.count("<default>-2-1")); + ASSERT_EQ(1u, moveConstructorSet.count("<default>-2-2")); + ASSERT_EQ(1u, moveConstructorSet.count("<default>-1-1")); + ASSERT_EQ(1u, moveConstructorSet.count("<default>-1-2")); + +#if !COMPILER(MSVC) + ASSERT_EQ(12u, totalDestructorCalls); +#else + // Since the move constructor is called 3 more times on Windows (see above), we will have 3 more destructor calls. + ASSERT_EQ(15u, totalDestructorCalls); +#endif + ASSERT_EQ(3u, totalIsolatedCopyCalls); + +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/DateMath.cpp b/Tools/TestWebKitAPI/Tests/WTF/DateMath.cpp new file mode 100644 index 000000000..463041d48 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/DateMath.cpp @@ -0,0 +1,208 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "Test.h" +#include <wtf/DateMath.h> + +namespace TestWebKitAPI { + +// Note: The results of these function look weird if you do not understand the following mappings: +// dayOfWeek: [0, 6] 0 being Monday, day: [1, 31], month: [0, 11], year: ex: 2011, +// hours: [0, 23], minutes: [0, 59], seconds: [0, 59], utcOffset: [-720,720]. + +TEST(WTF_DateMath, dateToDaysFrom1970) +{ + EXPECT_EQ(0.0, dateToDaysFrom1970(1970, 0, 1)); + EXPECT_EQ(157.0, dateToDaysFrom1970(1970, 5, 7)); + EXPECT_EQ(-145.0, dateToDaysFrom1970(1969, 7, 9)); + EXPECT_EQ(16322, dateToDaysFrom1970(2014, 8, 9)); +} + + +TEST(WTF_DateMath, isLeapYear) +{ + EXPECT_TRUE(isLeapYear(1804)); + EXPECT_FALSE(isLeapYear(1900)); + EXPECT_TRUE(isLeapYear(1968)); + EXPECT_TRUE(isLeapYear(1976)); + EXPECT_TRUE(isLeapYear(2000)); + EXPECT_FALSE(isLeapYear(2010)); + EXPECT_TRUE(isLeapYear(2012)); + EXPECT_FALSE(isLeapYear(2100)); +} + +TEST(WTF_DateMath, msToYear) +{ + EXPECT_EQ(1962, msToYear(-220953600000)); + EXPECT_EQ(1970, msToYear(0)); + EXPECT_EQ(1970, msToYear(100)); + EXPECT_EQ(1977, msToYear(220953600000)); + EXPECT_EQ(2013, msToYear(1365318000000)); +} + +TEST(WTF_DateMath, msToDays) +{ + EXPECT_EQ(0, msToDays(0)); + EXPECT_EQ(2557, msToDays(220953600000)); + EXPECT_EQ(255, msToDays(22095360000)); + EXPECT_EQ(25, msToDays(2209536000)); + EXPECT_EQ(2, msToDays(220953600)); + EXPECT_EQ(0, msToDays(22095360)); + EXPECT_EQ(0, msToDays(2209536)); +} + +TEST(WTF_DateMath, msToMinutes) +{ + EXPECT_EQ(0, msToMinutes(0)); + EXPECT_EQ(0, msToMinutes(220953600000)); + EXPECT_EQ(36, msToMinutes(22095360000)); + EXPECT_EQ(36, msToMinutes(22095360000)); + EXPECT_EQ(45, msToMinutes(2209536000)); + EXPECT_EQ(22, msToMinutes(220953600)); + EXPECT_EQ(8, msToMinutes(22095360)); + EXPECT_EQ(36, msToMinutes(2209536)); +} + +TEST(WTF_DateMath, msToHours) +{ + EXPECT_EQ(0, msToHours(0)); + EXPECT_EQ(8, msToHours(220953600000)); + EXPECT_EQ(17, msToHours(22095360000)); + EXPECT_EQ(13, msToHours(2209536000)); + EXPECT_EQ(13, msToHours(220953600)); + EXPECT_EQ(6, msToHours(22095360)); + EXPECT_EQ(0, msToHours(2209536)); +} + +TEST(WTF_DateMath, dayInYear) +{ + EXPECT_EQ(59, dayInYear(2015, 2, 1)); + EXPECT_EQ(60, dayInYear(2012, 2, 1)); + EXPECT_EQ(0, dayInYear(2015, 0, 1)); + EXPECT_EQ(31, dayInYear(2015, 1, 1)); +} + +TEST(WTF_DateMath, monthFromDayInYear) +{ + EXPECT_EQ(2, monthFromDayInYear(59, false)); + EXPECT_EQ(1, monthFromDayInYear(59, true)); + EXPECT_EQ(2, monthFromDayInYear(60, true)); + EXPECT_EQ(0, monthFromDayInYear(0, false)); + EXPECT_EQ(0, monthFromDayInYear(0, true)); + EXPECT_EQ(1, monthFromDayInYear(31, true)); + EXPECT_EQ(1, monthFromDayInYear(31, false)); +} + +TEST(WTF_DateMath, dayInMonthFromDayInYear) +{ + EXPECT_EQ(1, dayInMonthFromDayInYear(0, false)); + EXPECT_EQ(1, dayInMonthFromDayInYear(0, true)); + EXPECT_EQ(1, dayInMonthFromDayInYear(59, false)); + EXPECT_EQ(29, dayInMonthFromDayInYear(59, true)); + EXPECT_EQ(1, dayInMonthFromDayInYear(60, true)); + EXPECT_EQ(1, dayInMonthFromDayInYear(0, false)); + EXPECT_EQ(1, dayInMonthFromDayInYear(0, true)); + EXPECT_EQ(31, dayInMonthFromDayInYear(30, true)); + EXPECT_EQ(31, dayInMonthFromDayInYear(30, false)); + EXPECT_EQ(31, dayInMonthFromDayInYear(365, true)); + EXPECT_EQ(32, dayInMonthFromDayInYear(365, false)); + EXPECT_EQ(32, dayInMonthFromDayInYear(366, true)); +} + +TEST(WTF_DateMath, calculateLocalTimeOffset) +{ + // DST Start: April 30, 1967 (02:00 am) + LocalTimeOffset dstStart1967 = calculateLocalTimeOffset(-84301200000, WTF::LocalTime); + EXPECT_TRUE(dstStart1967.isDST); + EXPECT_EQ(-25200000, dstStart1967.offset); + + // November 1, 1967 (02:00 am) + LocalTimeOffset dstAlmostEnd1967 = calculateLocalTimeOffset(-68317200000, WTF::LocalTime); + EXPECT_TRUE(dstAlmostEnd1967.isDST); + EXPECT_EQ(-25200000, dstAlmostEnd1967.offset); + + // DST End: November 11, 1967 (02:00 am) + LocalTimeOffset dstEnd1967 = calculateLocalTimeOffset(-67536000000, WTF::LocalTime); + EXPECT_FALSE(dstEnd1967.isDST); + EXPECT_EQ(-25200000, dstStart1967.offset); + + // DST Start: April 3, 1988 (02:00 am) + LocalTimeOffset dstStart1988 = calculateLocalTimeOffset(576054000000, WTF::LocalTime); + EXPECT_TRUE(dstStart1988.isDST); + EXPECT_EQ(-25200000, dstStart1988.offset); + + // DST End: November 4, 2012 (02:00 am) + LocalTimeOffset dstEnd2012 = calculateLocalTimeOffset(1352012400000, WTF::LocalTime); + EXPECT_FALSE(dstEnd2012.isDST); + EXPECT_EQ(-28800000, dstEnd2012.offset); + + // DST Begin: March 8, 2015 + LocalTimeOffset dstBegin2015 = calculateLocalTimeOffset(1425801600000, WTF::LocalTime); + EXPECT_TRUE(dstBegin2015.isDST); + EXPECT_EQ(-25200000, dstBegin2015.offset); + + LocalTimeOffset dstBegin2015UTC = calculateLocalTimeOffset(1425801600000, WTF::UTCTime); + EXPECT_FALSE(dstBegin2015UTC.isDST); + EXPECT_EQ(-28800000, dstBegin2015UTC.offset); + + // DST End: November 1, 2015 + LocalTimeOffset dstEnd2015 = calculateLocalTimeOffset(1446361200000, WTF::LocalTime); + EXPECT_FALSE(dstEnd2015.isDST); + EXPECT_EQ(-28800000, dstEnd2015.offset); + + // DST Begin: March 13, 2016 + LocalTimeOffset dstBegin2016 = calculateLocalTimeOffset(1458111600000, WTF::LocalTime); + EXPECT_TRUE(dstBegin2016.isDST); + EXPECT_EQ(-25200000, dstBegin2016.offset); + + // DST End: November 6, 2016 + LocalTimeOffset dstEnd2016 = calculateLocalTimeOffset(1478415600000, WTF::LocalTime); + EXPECT_FALSE(dstEnd2016.isDST); + EXPECT_EQ(-28800000, dstEnd2016.offset); + + // DST Begin: March 12, 2017 + LocalTimeOffset dstBegin2017 = calculateLocalTimeOffset(1489305600000, WTF::LocalTime); + EXPECT_TRUE(dstBegin2017.isDST); + EXPECT_EQ(-25200000, dstBegin2017.offset); + + // DST End: November 5, 2017 + LocalTimeOffset dstEnd2017 = calculateLocalTimeOffset(1509865200000, WTF::LocalTime); + EXPECT_FALSE(dstEnd2017.isDST); + EXPECT_EQ(-28800000, dstEnd2017.offset); + + // DST Begin: March 11, 2018 + LocalTimeOffset dstBegin2018 = calculateLocalTimeOffset(1520755200000, WTF::LocalTime); + EXPECT_TRUE(dstBegin2018.isDST); + EXPECT_EQ(-25200000, dstBegin2018.offset); + + // DST End: November 4, 2018 + LocalTimeOffset dstEnd2018 = calculateLocalTimeOffset(1541314800000, WTF::LocalTime); + EXPECT_FALSE(dstEnd2018.isDST); + EXPECT_EQ(-28800000, dstEnd2018.offset); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/DeletedAddressOfOperator.h b/Tools/TestWebKitAPI/Tests/WTF/DeletedAddressOfOperator.h new file mode 100644 index 000000000..31d5d80b9 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/DeletedAddressOfOperator.h @@ -0,0 +1,84 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include <wtf/HashFunctions.h> +#include <wtf/HashTraits.h> + +class DeletedAddressOfOperator { +public: + DeletedAddressOfOperator() + : m_value(0) + { + } + + DeletedAddressOfOperator(unsigned value) + : m_value(value) + { + } + + DeletedAddressOfOperator* operator&() = delete; + + unsigned value() const + { + return m_value; + } + + friend bool operator==(const DeletedAddressOfOperator& a, const DeletedAddressOfOperator& b) + { + return a.m_value == b.m_value; + } + +private: + unsigned m_value; +}; + +namespace WTF { + +template<> struct HashTraits<DeletedAddressOfOperator> : public GenericHashTraits<DeletedAddressOfOperator> { + static const bool emptyValueIsZero = true; + + static void constructDeletedValue(DeletedAddressOfOperator& slot) { slot = DeletedAddressOfOperator(std::numeric_limits<unsigned>::max()); } + static bool isDeletedValue(const DeletedAddressOfOperator& slot) { return slot.value() == std::numeric_limits<unsigned>::max(); } +}; + +template<> struct DefaultHash<DeletedAddressOfOperator> { + struct Hash { + static unsigned hash(const DeletedAddressOfOperator& key) + { + return intHash(key.value()); + } + + static bool equal(const DeletedAddressOfOperator& a, const DeletedAddressOfOperator& b) + { + return a == b; + } + + static const bool safeToCompareToEmptyOrDeleted = true; + }; +}; +} + diff --git a/Tools/TestWebKitAPI/Tests/WTF/Deque.cpp b/Tools/TestWebKitAPI/Tests/WTF/Deque.cpp new file mode 100644 index 000000000..83f1f82ee --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/Deque.cpp @@ -0,0 +1,191 @@ +/* + * Copyright (C) 2011 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "MoveOnly.h" +#include <wtf/Deque.h> + +namespace TestWebKitAPI { + +TEST(WTF_Deque, Iterator) +{ + Deque<int> deque; + deque.append(11); + deque.prepend(10); + deque.append(12); + deque.append(13); + + Deque<int>::iterator it = deque.begin(); + Deque<int>::iterator end = deque.end(); + EXPECT_TRUE(end != it); + + EXPECT_EQ(10, *it); + ++it; + EXPECT_EQ(11, *it); + ++it; + EXPECT_EQ(12, *it); + ++it; + EXPECT_EQ(13, *it); + ++it; + + EXPECT_TRUE(end == it); +} + +TEST(WTF_Deque, InitializerList) +{ + Deque<int> deque = { 1, 2, 3, 4 }; + + EXPECT_EQ(4u, deque.size()); + + auto it = deque.begin(); + auto end = deque.end(); + EXPECT_TRUE(end != it); + + EXPECT_EQ(1, *it); + ++it; + EXPECT_EQ(2, *it); + ++it; + EXPECT_EQ(3, *it); + ++it; + EXPECT_EQ(4, *it); + ++it; + + EXPECT_TRUE(end == it); +} + +TEST(WTF, DequeReverseIterator) +{ + Deque<int> deque; + deque.append(11); + deque.prepend(10); + deque.append(12); + deque.append(13); + + Deque<int>::reverse_iterator it = deque.rbegin(); + Deque<int>::reverse_iterator end = deque.rend(); + EXPECT_TRUE(end != it); + + EXPECT_EQ(13, *it); + ++it; + EXPECT_EQ(12, *it); + ++it; + EXPECT_EQ(11, *it); + ++it; + EXPECT_EQ(10, *it); + ++it; + + EXPECT_TRUE(end == it); +} + +TEST(WTF_Deque, Remove) +{ + Deque<int> deque; + deque.append(11); + deque.prepend(10); + deque.append(12); + deque.append(13); + + EXPECT_EQ(10, deque.first()); + EXPECT_EQ(13, deque.last()); + + deque.removeLast(); + EXPECT_EQ(10, deque.first()); + EXPECT_EQ(12, deque.last()); + + deque.removeFirst(); + EXPECT_EQ(11, deque.first()); + EXPECT_EQ(12, deque.last()); + + deque.removeFirst(); + EXPECT_EQ(12, deque.first()); + EXPECT_EQ(12, deque.last()); + + deque.removeLast(); + EXPECT_TRUE(deque.isEmpty()); +} + +TEST(WTF_Deque, MoveOnly) +{ + Deque<MoveOnly> deque; + + deque.append(MoveOnly(1)); + deque.prepend(MoveOnly(0)); + + EXPECT_EQ(0U, deque.first().value()); + EXPECT_EQ(1U, deque.last().value()); + + auto first = deque.takeFirst(); + EXPECT_EQ(0U, first.value()); + + auto last = deque.takeLast(); + EXPECT_EQ(1U, last.value()); +} + +TEST(WTF_Deque, MoveConstructor) +{ + Deque<MoveOnly, 4> deque; + + for (unsigned i = 0; i < 10; ++i) + deque.append(MoveOnly(i)); + + EXPECT_EQ(10u, deque.size()); + + Deque<MoveOnly, 4> deque2 = WTFMove(deque); + + EXPECT_EQ(10u, deque2.size()); + + unsigned i = 0; + for (auto& element : deque2) { + EXPECT_EQ(i, element.value()); + ++i; + } +} + +TEST(WTF_Deque, MoveAssignmentOperator) +{ + Deque<MoveOnly, 4> deque1; + + for (unsigned i = 0; i < 10; ++i) + deque1.append(MoveOnly(i)); + + EXPECT_EQ(10u, deque1.size()); + + Deque<MoveOnly, 4> deque2; + for (unsigned i = 0; i < 10; ++i) + deque2.append(MoveOnly(i * 2)); + + deque1 = WTFMove(deque2); + + EXPECT_EQ(10u, deque2.size()); + + unsigned i = 0; + for (auto& element : deque1) { + EXPECT_EQ(i * 2, element.value()); + ++i; + } +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/EnumTraits.cpp b/Tools/TestWebKitAPI/Tests/WTF/EnumTraits.cpp new file mode 100644 index 000000000..0246fde29 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/EnumTraits.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <wtf/EnumTraits.h> + +enum class TestEnum { + A, + B, + C, +}; + +namespace WTF { +template<> struct EnumTraits<TestEnum> { + using values = EnumValues<TestEnum, TestEnum::A, TestEnum::B, TestEnum::C>; +}; +} + +namespace TestWebKitAPI { + +static_assert(WTF::isValidEnum<TestEnum>(0), ""); +static_assert(!WTF::isValidEnum<TestEnum>(-1), ""); +static_assert(!WTF::isValidEnum<TestEnum>(3), ""); + +TEST(WTF_EnumTraits, IsValidEnum) +{ + EXPECT_TRUE(isValidEnum<TestEnum>(0)); + EXPECT_FALSE(isValidEnum<TestEnum>(-1)); + EXPECT_FALSE(isValidEnum<TestEnum>(3)); +} + +} diff --git a/Tools/TestWebKitAPI/Tests/WTF/Expected.cpp b/Tools/TestWebKitAPI/Tests/WTF/Expected.cpp new file mode 100644 index 000000000..73654c5dd --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/Expected.cpp @@ -0,0 +1,512 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "RefLogger.h" + +#include <string> +#include <unordered_map> + +#include <wtf/Expected.h> +#include <wtf/Ref.h> + +namespace WTF { + +template <class E> std::ostream& operator<<(std::ostream& os, const UnexpectedType<E>& u) +{ + return os << u.value(); +} + +template <class T, class E> std::ostream& operator<<(std::ostream& os, const Expected<T, E>& e) +{ + if (e.hasValue()) + return os << e.value(); + return os << e.error(); +} + +template <class E> std::ostream& operator<<(std::ostream& os, const Expected<void, E>& e) +{ + if (e.hasValue()) + return os << ""; + return os << e.error(); +} + +} + +namespace TestWebKitAPI { + +constexpr const char* oops = "oops"; +constexpr const char* foof = "foof"; + +TEST(WTF_Expected, UnexpectedType) +{ + { + auto u = UnexpectedType<int>(42); + EXPECT_EQ(u.value(), 42); + constexpr auto c = makeUnexpected(42); + EXPECT_EQ(c.value(), 42); + EXPECT_EQ(u, c); + EXPECT_FALSE(u != c); + EXPECT_FALSE(u < c); + EXPECT_FALSE(u > c); + EXPECT_LE(u, c); + EXPECT_GE(u, c); + } + { + auto c = makeUnexpected(oops); + EXPECT_EQ(c.value(), oops); + } + { + auto s = makeUnexpected(std::string(oops)); + EXPECT_EQ(s.value(), oops); + } + { + constexpr auto s0 = makeUnexpected(oops); + constexpr auto s1(s0); + EXPECT_EQ(s0, s1); + } +} + +struct foo { + int v; + foo(int v) + : v(v) + { } + ~foo() { } + bool operator==(const foo& y) const { return v == y.v; } + friend std::ostream& operator<<(std::ostream&, const foo&); +}; +std::ostream& operator<<(std::ostream& os, const foo& f) { return os << f.v; } + +TEST(WTF_Expected, expected) +{ + typedef Expected<int, const char*> E; + typedef Expected<int, const void*> EV; + typedef Expected<foo, const char*> FooChar; + typedef Expected<foo, std::string> FooString; + { + auto e = E(); + EXPECT_TRUE(e.hasValue()); + EXPECT_EQ(e.value(), 0); + EXPECT_EQ(e.valueOr(3.14), 0); + } + { + constexpr E e; + EXPECT_TRUE(e.hasValue()); + EXPECT_EQ(e.value(), 0); + EXPECT_EQ(e.valueOr(3.14), 0); + } + { + auto e = E(42); + EXPECT_TRUE(e.hasValue()); + EXPECT_EQ(e.value(), 42); + EXPECT_EQ(e.valueOr(3.14), 42); + const auto e2(e); + EXPECT_TRUE(e2.hasValue()); + EXPECT_EQ(e2.value(), 42); + EXPECT_EQ(e2.valueOr(3.14), 42); + E e3; + e3 = e2; + EXPECT_TRUE(e3.hasValue()); + EXPECT_EQ(e3.value(), 42); + EXPECT_EQ(e3.valueOr(3.14), 42); + const E e4 = e2; + EXPECT_TRUE(e4.hasValue()); + EXPECT_EQ(e4.value(), 42); + EXPECT_EQ(e4.valueOr(3.14), 42); + } + { + constexpr E c(42); + EXPECT_TRUE(c.hasValue()); + EXPECT_EQ(c.value(), 42); + EXPECT_EQ(c.valueOr(3.14), 42); + constexpr const auto c2(c); + EXPECT_TRUE(c2.hasValue()); + EXPECT_EQ(c2.value(), 42); + EXPECT_EQ(c2.valueOr(3.14), 42); + } + { + auto u = E(makeUnexpected(oops)); + EXPECT_FALSE(u.hasValue()); + EXPECT_EQ(u.error(), oops); + EXPECT_EQ(u.getUnexpected().value(), oops); + EXPECT_EQ(u.valueOr(3.14), 3); + } + { + auto uv = EV(makeUnexpected(oops)); + EXPECT_FALSE(uv.hasValue()); + EXPECT_EQ(uv.error(), oops); + EXPECT_EQ(uv.getUnexpected().value(), oops); + EXPECT_EQ(uv.valueOr(3.14), 3); + } + { + E e = makeUnexpected(oops); + EXPECT_FALSE(e.hasValue()); + EXPECT_EQ(e.error(), oops); + EXPECT_EQ(e.getUnexpected().value(), oops); + EXPECT_EQ(e.valueOr(3.14), 3); + } + { + auto e = makeExpectedFromError<int, const char*>(oops); + EXPECT_FALSE(e.hasValue()); + EXPECT_EQ(e.error(), oops); + EXPECT_EQ(e.getUnexpected().value(), oops); + EXPECT_EQ(e.valueOr(3.14), 3); + } + { + auto e = makeExpectedFromError<int, const void*>(oops); + EXPECT_FALSE(e.hasValue()); + EXPECT_EQ(e.error(), oops); + EXPECT_EQ(e.getUnexpected().value(), oops); + EXPECT_EQ(e.valueOr(3.14), 3); + } + { + auto e = FooChar(42); + EXPECT_EQ(e->v, 42); + EXPECT_EQ((*e).v, 42); + } + { + auto e0 = E(42); + auto e1 = E(1024); + swap(e0, e1); + EXPECT_EQ(e0.value(), 1024); + EXPECT_EQ(e1.value(), 42); + } + { + auto e0 = E(makeUnexpected(oops)); + auto e1 = E(makeUnexpected(foof)); + swap(e0, e1); + EXPECT_EQ(e0.error(), foof); + EXPECT_EQ(e1.error(), oops); + } + { + FooChar c(foo(42)); + EXPECT_EQ(c->v, 42); + EXPECT_EQ((*c).v, 42); + } + { + FooString s(foo(42)); + EXPECT_EQ(s->v, 42); + EXPECT_EQ((*s).v, 42); + const char* message = "very long failure string, for very bad failure cases"; + FooString e0(makeUnexpected<std::string>(message)); + FooString e1(makeUnexpected<std::string>(message)); + FooString e2(makeUnexpected<std::string>(std::string())); + EXPECT_EQ(e0.error(), std::string(message)); + EXPECT_EQ(e0, e1); + EXPECT_NE(e0, e2); + FooString* e4 = new FooString(makeUnexpected<std::string>(message)); + FooString* e5 = new FooString(*e4); + EXPECT_EQ(e0, *e4); + delete e4; + EXPECT_EQ(e0, *e5); + delete e5; + } +} + +TEST(WTF_Expected, Expected_void) +{ + typedef Expected<void, const char*> E; + typedef Expected<void, const void*> EV; + typedef Expected<void, std::string> String; + { + auto e = E(); + EXPECT_TRUE(e.hasValue()); + const auto e2(e); + EXPECT_TRUE(e2.hasValue()); + EXPECT_EQ(e, e2); + E e3; + e3 = e2; + EXPECT_TRUE(e3.hasValue()); + EXPECT_EQ(e, e3); + } + { + constexpr E c; + EXPECT_TRUE(c.hasValue()); + constexpr const auto c2(c); + EXPECT_TRUE(c2.hasValue()); + EXPECT_EQ(c, c2); + } + { + auto u = E(makeUnexpected(oops)); + EXPECT_FALSE(u.hasValue()); + EXPECT_EQ(u.error(), oops); + EXPECT_EQ(u.getUnexpected().value(), oops); + } + { + auto uv = EV(makeUnexpected(oops)); + EXPECT_FALSE(uv.hasValue()); + EXPECT_EQ(uv.error(), oops); + EXPECT_EQ(uv.getUnexpected().value(), oops); + } + { + E e = makeUnexpected(oops); + EXPECT_FALSE(e.hasValue()); + EXPECT_EQ(e.error(), oops); + EXPECT_EQ(e.getUnexpected().value(), oops); + } + { + auto e = makeExpectedFromError<void, const char*>(oops); + EXPECT_FALSE(e.hasValue()); + EXPECT_EQ(e.error(), oops); + EXPECT_EQ(e.getUnexpected().value(), oops); + } + { + auto e = makeExpectedFromError<void, const void*>(oops); + EXPECT_FALSE(e.hasValue()); + EXPECT_EQ(e.error(), oops); + EXPECT_EQ(e.getUnexpected().value(), oops); + } + { + auto e0 = E(); + auto e1 = E(); + swap(e0, e1); + EXPECT_EQ(e0, e1); + } + { + auto e0 = E(makeUnexpected(oops)); + auto e1 = E(makeUnexpected(foof)); + swap(e0, e1); + EXPECT_EQ(e0.error(), foof); + EXPECT_EQ(e1.error(), oops); + } + { + const char* message = "very long failure string, for very bad failure cases"; + String e0(makeUnexpected<std::string>(message)); + String e1(makeUnexpected<std::string>(message)); + String e2(makeUnexpected<std::string>(std::string())); + EXPECT_EQ(e0.error(), std::string(message)); + EXPECT_EQ(e0, e1); + EXPECT_NE(e0, e2); + String* e4 = new String(makeUnexpected<std::string>(message)); + String* e5 = new String(*e4); + EXPECT_EQ(e0, *e4); + delete e4; + EXPECT_EQ(e0, *e5); + delete e5; + } +} + +TEST(WTF_Expected, comparison) +{ + typedef Expected<int, const char*> Ex; + typedef Expected<int, int> Er; + + // Two Expected, no errors. + EXPECT_EQ(Ex(42), Ex(42)); + EXPECT_NE(Ex(42), Ex(1024)); + EXPECT_LT(Ex(42), Ex(1024)); + EXPECT_GT(Ex(1024), Ex(42)); + EXPECT_LE(Ex(42), Ex(42)); + EXPECT_GE(Ex(42), Ex(42)); + EXPECT_LE(Ex(42), Ex(1024)); + EXPECT_GE(Ex(1024), Ex(42)); + + EXPECT_FALSE(Ex(42) == Ex(1024)); + EXPECT_FALSE(Ex(42) != Ex(42)); + EXPECT_FALSE(Ex(1024) < Ex(42)); + EXPECT_FALSE(Ex(42) > Ex(1024)); + EXPECT_FALSE(Ex(1024) < Ex(42)); + EXPECT_FALSE(Ex(42) >= Ex(1024)); + + // Two Expected, half errors. + EXPECT_FALSE(Ex(42) == Ex(makeUnexpected(oops))); + EXPECT_NE(Ex(42), Ex(makeUnexpected(oops))); + EXPECT_LT(Ex(42), Ex(makeUnexpected(oops))); + EXPECT_FALSE(Ex(42) > Ex(makeUnexpected(oops))); + EXPECT_LE(Ex(42), Ex(makeUnexpected(oops))); + EXPECT_FALSE(Ex(42) >= Ex(makeUnexpected(oops))); + + EXPECT_FALSE(Ex(makeUnexpected(oops)) == Ex(42)); + EXPECT_NE(Ex(makeUnexpected(oops)), Ex(42)); + EXPECT_FALSE(Ex(makeUnexpected(oops)) < Ex(42)); + EXPECT_GT(Ex(makeUnexpected(oops)), Ex(42)); + EXPECT_FALSE(Ex(makeUnexpected(oops)) <= Ex(42)); + EXPECT_GE(Ex(makeUnexpected(oops)), Ex(42)); + + // Two Expected, all errors. + EXPECT_EQ(Er(42), Er(42)); + EXPECT_NE(Er(42), Er(1024)); + EXPECT_LT(Er(42), Er(1024)); + EXPECT_GT(Er(1024), Er(42)); + EXPECT_LE(Er(42), Er(42)); + EXPECT_GE(Er(42), Er(42)); + EXPECT_LE(Er(42), Er(1024)); + EXPECT_GE(Er(1024), Er(42)); + + EXPECT_FALSE(Er(42) == Er(1024)); + EXPECT_FALSE(Er(42) != Er(42)); + EXPECT_FALSE(Er(1024) < Er(42)); + EXPECT_FALSE(Er(42) > Er(1024)); + EXPECT_FALSE(Er(1024) <= Er(42)); + EXPECT_FALSE(Er(42) >= Er(1024)); + + // One Expected, one value. + EXPECT_EQ(Ex(42), 42); + EXPECT_NE(Ex(42), 0); + EXPECT_LT(Ex(42), 1024); + EXPECT_GT(Ex(1024), 42); + EXPECT_LE(Ex(42), 42); + EXPECT_GE(Ex(42), 42); + EXPECT_LE(Ex(42), 1024); + EXPECT_GE(Ex(1024), 42); + + EXPECT_FALSE(Ex(42) == 0); + EXPECT_FALSE(Ex(42) != 42); + EXPECT_FALSE(Ex(1024) < 42); + EXPECT_FALSE(Ex(42) > 1024); + EXPECT_FALSE(Ex(1024) < 42); + EXPECT_FALSE(Ex(42) >= 1024); + + EXPECT_EQ(42, Ex(42)); + EXPECT_NE(42, Ex(1024)); + EXPECT_LT(42, Ex(1024)); + EXPECT_GT(1024, Ex(42)); + EXPECT_LE(42, Ex(42)); + EXPECT_GE(42, Ex(42)); + EXPECT_LE(42, Ex(1024)); + EXPECT_GE(1024, Ex(42)); + + EXPECT_FALSE(42 == Ex(1024)); + EXPECT_FALSE(42 != Ex(42)); + EXPECT_FALSE(1024 < Ex(42)); + EXPECT_FALSE(42 > Ex(1024)); + EXPECT_FALSE(1024 <= Ex(42)); + EXPECT_FALSE(42 >= Ex(1024)); + + // One Expected, one unexpected. + EXPECT_FALSE(Ex(42) == makeUnexpected(oops)); + EXPECT_NE(Ex(42), makeUnexpected(oops)); + EXPECT_LT(Ex(42), makeUnexpected(oops)); + EXPECT_FALSE(Ex(42) > makeUnexpected(oops)); + EXPECT_LE(Ex(42), makeUnexpected(oops)); + EXPECT_FALSE(Ex(42) >= makeUnexpected(oops)); + + EXPECT_FALSE(makeUnexpected(oops) == Ex(42)); + EXPECT_NE(makeUnexpected(oops), Ex(42)); + EXPECT_FALSE(makeUnexpected(oops) < Ex(42)); + EXPECT_GT(makeUnexpected(oops), Ex(42)); + EXPECT_FALSE(makeUnexpected(oops) <= Ex(42)); + EXPECT_GE(makeUnexpected(oops), Ex(42)); +} + +struct NonTrivialDtor { + ~NonTrivialDtor() { ++count; } + static int count; +}; +int NonTrivialDtor::count = 0; + +TEST(WTF_Expected, destructors) +{ + typedef Expected<NonTrivialDtor, const char*> NT; + typedef Expected<const char*, NonTrivialDtor> TN; + typedef Expected<NonTrivialDtor, NonTrivialDtor> NN; + typedef Expected<void, NonTrivialDtor> VN; + EXPECT_EQ(NonTrivialDtor::count, 0); + { NT nt; } + EXPECT_EQ(NonTrivialDtor::count, 1); + { NT nt = makeUnexpected(oops); } + EXPECT_EQ(NonTrivialDtor::count, 1); + { TN tn; } + EXPECT_EQ(NonTrivialDtor::count, 1); + { TN tn = makeUnexpected(NonTrivialDtor()); } + EXPECT_EQ(NonTrivialDtor::count, 4); + { NN nn; } + EXPECT_EQ(NonTrivialDtor::count, 5); + { NN nn = makeUnexpected(NonTrivialDtor()); } + EXPECT_EQ(NonTrivialDtor::count, 8); + { VN vn; } + EXPECT_EQ(NonTrivialDtor::count, 8); + { VN vn = makeUnexpected(NonTrivialDtor()); } + EXPECT_EQ(NonTrivialDtor::count, 11); +} + +TEST(WTF_Expected, hash) +{ + typedef Expected<int, const char*> E; + std::unordered_map<E, int> m; + m.insert({ E(42), 42 }); + m.insert({ E(makeUnexpected(oops)), 5 }); + m.insert({ E(1024), 1024 }); + m.insert({ E(makeUnexpected(foof)), 0xf00f }); + EXPECT_EQ(m[E(42)], 42); + EXPECT_EQ(m[E(1024)], 1024); + EXPECT_EQ(m[E(makeUnexpected(oops))], 5); + EXPECT_EQ(m[E(makeUnexpected(foof))], 0xf00f); +} + +TEST(WTF_Expected, hash_void) +{ + typedef Expected<void, const char*> E; + std::unordered_map<E, int> m; + m.insert({ E(), 42 }); + m.insert({ E(makeUnexpected(oops)), 5 }); + m.insert({ E(makeUnexpected(foof)), 0xf00f }); + EXPECT_EQ(m[E()], 42); + EXPECT_EQ(m[E(makeUnexpected(oops))], 5); + EXPECT_EQ(m[E(makeUnexpected(foof))], 0xf00f); +} + +TEST(WTF_Expected, Ref) +{ + { + RefLogger a("a"); + Expected<Ref<RefLogger>, int> expected = Ref<RefLogger>(a); + EXPECT_TRUE(expected.hasValue()); + EXPECT_EQ(&a, expected.value().ptr()); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + RefLogger a("a"); + Expected<Ref<RefLogger>, int> expected = makeExpected<Ref<RefLogger>, int>(Ref<RefLogger>(a)); + EXPECT_TRUE(expected.hasValue()); + EXPECT_EQ(&a, expected.value().ptr()); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + RefLogger a("a"); + Expected<int, Ref<RefLogger>> expected = makeUnexpected(Ref<RefLogger>(a)); + EXPECT_FALSE(expected.hasValue()); + EXPECT_EQ(&a, expected.error().ptr()); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + RefLogger a("a"); + Expected<void, Ref<RefLogger>> expected = makeUnexpected(Ref<RefLogger>(a)); + EXPECT_FALSE(expected.hasValue()); + EXPECT_EQ(&a, expected.error().ptr()); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +} // namespace TestWebkitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/Functional.cpp b/Tools/TestWebKitAPI/Tests/WTF/Functional.cpp deleted file mode 100644 index cf8c3c39c..000000000 --- a/Tools/TestWebKitAPI/Tests/WTF/Functional.cpp +++ /dev/null @@ -1,218 +0,0 @@ -/* - * Copyright (C) 2011 Apple Inc. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF - * THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "config.h" -#include <wtf/RefCounted.h> -#include <wtf/Functional.h> - -namespace TestWebKitAPI { - -static int returnFortyTwo() -{ - return 42; -} - -TEST(FunctionalTest, Basic) -{ - Function<int ()> emptyFunction; - ASSERT_TRUE(emptyFunction.isNull()); - - Function<int ()> returnFortyTwoFunction = bind(returnFortyTwo); - ASSERT_FALSE(returnFortyTwoFunction.isNull()); - ASSERT_EQ(42, returnFortyTwoFunction()); -} - -static int multiplyByTwo(int n) -{ - return n * 2; -} - -static double multiplyByOneAndAHalf(double d) -{ - return d * 1.5; -} - -TEST(FunctionalTest, UnaryBind) -{ - Function<int ()> multiplyFourByTwoFunction = bind(multiplyByTwo, 4); - ASSERT_EQ(8, multiplyFourByTwoFunction()); - - Function<double ()> multiplyByOneAndAHalfFunction = bind(multiplyByOneAndAHalf, 3); - ASSERT_EQ(4.5, multiplyByOneAndAHalfFunction()); -} - -static int multiply(int x, int y) -{ - return x * y; -} - -static int subtract(int x, int y) -{ - return x - y; -} - -TEST(FunctionalTest, BinaryBind) -{ - Function<int ()> multiplyFourByTwoFunction = bind(multiply, 4, 2); - ASSERT_EQ(8, multiplyFourByTwoFunction()); - - Function<int ()> subtractTwoFromFourFunction = bind(subtract, 4, 2); - ASSERT_EQ(2, subtractTwoFromFourFunction()); -} - -class A { -public: - explicit A(int i) - : m_i(i) - { - } - - int f() { return m_i; } - int addF(int j) { return m_i + j; } - -private: - int m_i; -}; - -TEST(FunctionalTest, MemberFunctionBind) -{ - A a(10); - Function<int ()> function1 = bind(&A::f, &a); - ASSERT_EQ(10, function1()); - - Function<int ()> function2 = bind(&A::addF, &a, 15); - ASSERT_EQ(25, function2()); -} - -class B { -public: - B() - : m_numRefCalls(0) - , m_numDerefCalls(0) - { - } - - ~B() - { - } - - void ref() - { - m_numRefCalls++; - } - - void deref() - { - m_numDerefCalls++; - } - - void f() { ASSERT_GT(m_numRefCalls, 0); } - void g(int) { ASSERT_GT(m_numRefCalls, 0); } - - int m_numRefCalls; - int m_numDerefCalls; -}; - -TEST(FunctionalTest, MemberFunctionBindRefDeref) -{ - B b; - - { - Function<void ()> function1 = bind(&B::f, &b); - function1(); - - Function<void ()> function2 = bind(&B::g, &b, 10); - function2(); - } - - ASSERT_TRUE(b.m_numRefCalls == b.m_numDerefCalls); - ASSERT_GT(b.m_numRefCalls, 0); - -} - -class Number : public RefCounted<Number> { -public: - static PassRefPtr<Number> create(int value) - { - return adoptRef(new Number(value)); - } - - ~Number() - { - m_value = 0; - } - - int value() const { return m_value; } - -private: - explicit Number(int value) - : m_value(value) - { - } - - int m_value; -}; - -static int multiplyNumberByTwo(Number* number) -{ - return number->value() * 2; -} - -TEST(FunctionalTest, RefCountedStorage) -{ - RefPtr<Number> five = Number::create(5); - Function<int ()> multiplyFiveByTwoFunction = bind(multiplyNumberByTwo, five); - ASSERT_EQ(10, multiplyFiveByTwoFunction()); - - Function<int ()> multiplyFourByTwoFunction = bind(multiplyNumberByTwo, Number::create(4)); - ASSERT_EQ(8, multiplyFourByTwoFunction()); - - RefPtr<Number> six = Number::create(6); - Function<int ()> multiplySixByTwoFunction = bind(multiplyNumberByTwo, six.release()); - ASSERT_FALSE(six); - ASSERT_EQ(12, multiplySixByTwoFunction()); -} - -namespace RefAndDerefTests { - - template<typename T> struct RefCounted { - void ref(); - void deref(); - }; - struct Connection : RefCounted<Connection> { }; - COMPILE_ASSERT(WTF::HasRefAndDeref<Connection>::value, class_has_ref_and_deref); - - struct NoRefOrDeref { }; - COMPILE_ASSERT(!WTF::HasRefAndDeref<NoRefOrDeref>::value, class_has_no_ref_or_deref); - - struct RefOnly { void ref(); }; - COMPILE_ASSERT(!WTF::HasRefAndDeref<RefOnly>::value, class_has_ref_only); - - struct DerefOnly { void deref(); }; - COMPILE_ASSERT(!WTF::HasRefAndDeref<DerefOnly>::value, class_has_deref_only); - -} - -} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/HashCountedSet.cpp b/Tools/TestWebKitAPI/Tests/WTF/HashCountedSet.cpp new file mode 100644 index 000000000..9627bd05a --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/HashCountedSet.cpp @@ -0,0 +1,468 @@ +/* + * Copyright (C) 2016 Apple Inc. All rights reserved. + * Copyright (C) 2011 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "Counters.h" +#include "MoveOnly.h" +#include "RefLogger.h" +#include <string> +#include <wtf/HashCountedSet.h> +#include <wtf/text/StringHash.h> + +namespace TestWebKitAPI { + +typedef WTF::HashCountedSet<int> IntHashCountedSet; + +TEST(WTF_HashCountedSet, HashTableIteratorComparison) +{ + IntHashCountedSet hashCountedSet; + hashCountedSet.add(1); + ASSERT_TRUE(hashCountedSet.begin() != hashCountedSet.end()); + ASSERT_FALSE(hashCountedSet.begin() == hashCountedSet.end()); + + IntHashCountedSet::const_iterator begin = hashCountedSet.begin(); + ASSERT_TRUE(begin == hashCountedSet.begin()); + ASSERT_TRUE(hashCountedSet.begin() == begin); + ASSERT_TRUE(begin != hashCountedSet.end()); + ASSERT_TRUE(hashCountedSet.end() != begin); + ASSERT_FALSE(begin != hashCountedSet.begin()); + ASSERT_FALSE(hashCountedSet.begin() != begin); + ASSERT_FALSE(begin == hashCountedSet.end()); + ASSERT_FALSE(hashCountedSet.end() == begin); +} + +struct TestDoubleHashTraits : HashTraits<double> { + static const int minimumTableSize = 8; +}; + +typedef HashCountedSet<double, DefaultHash<double>::Hash, TestDoubleHashTraits> DoubleHashCountedSet; + +static int bucketForKey(double key) +{ + return DefaultHash<double>::Hash::hash(key) & (TestDoubleHashTraits::minimumTableSize - 1); +} + +TEST(WTF_HashCountedSet, DoubleHashCollisions) +{ + // The "clobber" key here is one that ends up stealing the bucket that the -0 key + // originally wants to be in. This makes the 0 and -0 keys collide and the test then + // fails unless the FloatHash::equals() implementation can distinguish them. + const double clobberKey = 6; + const double zeroKey = 0; + const double negativeZeroKey = -zeroKey; + + DoubleHashCountedSet hashCountedSet; + + hashCountedSet.add(clobberKey); + + ASSERT_EQ(hashCountedSet.count(clobberKey), 1u); + ASSERT_EQ(hashCountedSet.count(zeroKey), 0u); + ASSERT_EQ(hashCountedSet.count(negativeZeroKey), 0u); + + hashCountedSet.add(zeroKey); + hashCountedSet.add(negativeZeroKey); + + ASSERT_EQ(bucketForKey(clobberKey), bucketForKey(negativeZeroKey)); + ASSERT_EQ(hashCountedSet.count(clobberKey), 1u); + ASSERT_EQ(hashCountedSet.count(zeroKey), 1u); + ASSERT_EQ(hashCountedSet.count(negativeZeroKey), 1u); + + hashCountedSet.add(clobberKey); + hashCountedSet.add(zeroKey); + hashCountedSet.add(negativeZeroKey); + + ASSERT_EQ(hashCountedSet.count(clobberKey), 2u); + ASSERT_EQ(hashCountedSet.count(zeroKey), 2u); + ASSERT_EQ(hashCountedSet.count(negativeZeroKey), 2u); + + hashCountedSet.add(clobberKey, 12); + hashCountedSet.add(zeroKey, 15); + hashCountedSet.add(negativeZeroKey, 17); + + ASSERT_EQ(hashCountedSet.count(clobberKey), 14u); + ASSERT_EQ(hashCountedSet.count(zeroKey), 17u); + ASSERT_EQ(hashCountedSet.count(negativeZeroKey), 19u); +} + +TEST(WTF_HashCountedSet, DoubleHashCollisionsInitialCount) +{ + // The "clobber" key here is one that ends up stealing the bucket that the -0 key + // originally wants to be in. This makes the 0 and -0 keys collide and the test then + // fails unless the FloatHash::equals() implementation can distinguish them. + const double clobberKey = 6; + const double zeroKey = 0; + const double negativeZeroKey = -zeroKey; + + DoubleHashCountedSet hashCountedSet; + + hashCountedSet.add(clobberKey, 5); + + ASSERT_EQ(hashCountedSet.count(clobberKey), 5u); + ASSERT_EQ(hashCountedSet.count(zeroKey), 0u); + ASSERT_EQ(hashCountedSet.count(negativeZeroKey), 0u); + + hashCountedSet.add(zeroKey, 22); + hashCountedSet.add(negativeZeroKey, 0); + + ASSERT_EQ(bucketForKey(clobberKey), bucketForKey(negativeZeroKey)); + ASSERT_EQ(hashCountedSet.count(clobberKey), 5u); + ASSERT_EQ(hashCountedSet.count(zeroKey), 22u); + ASSERT_EQ(hashCountedSet.count(negativeZeroKey), 0u); + + hashCountedSet.add(clobberKey); + hashCountedSet.add(zeroKey); + hashCountedSet.add(negativeZeroKey); + + ASSERT_EQ(hashCountedSet.count(clobberKey), 6u); + ASSERT_EQ(hashCountedSet.count(zeroKey), 23u); + ASSERT_EQ(hashCountedSet.count(negativeZeroKey), 1u); +} + + +TEST(WTF_HashCountedSet, MoveOnlyKeys) +{ + HashCountedSet<MoveOnly> moveOnlyKeys; + + for (size_t i = 0; i < 100; ++i) { + MoveOnly moveOnly(i + 1); + moveOnlyKeys.add(WTFMove(moveOnly)); + } + + for (size_t i = 0; i < 100; ++i) { + auto it = moveOnlyKeys.find(MoveOnly(i + 1)); + ASSERT_FALSE(it == moveOnlyKeys.end()); + ASSERT_EQ(it->value, 1u); + } + + for (size_t i = 0; i < 100; ++i) + ASSERT_FALSE(moveOnlyKeys.add(MoveOnly(i + 1)).isNewEntry); + + for (size_t i = 0; i < 100; ++i) + ASSERT_FALSE(moveOnlyKeys.remove(MoveOnly(i + 1))); + + for (size_t i = 0; i < 100; ++i) + ASSERT_TRUE(moveOnlyKeys.remove(MoveOnly(i + 1))); + + ASSERT_TRUE(moveOnlyKeys.isEmpty()); +} + +TEST(WTF_HashCountedSet, MoveOnlyKeysInitialCount) +{ + HashCountedSet<MoveOnly> moveOnlyKeys; + + for (size_t i = 0; i < 100; ++i) { + MoveOnly moveOnly(i + 1); + moveOnlyKeys.add(WTFMove(moveOnly), i + 1); + } + + for (size_t i = 0; i < 100; ++i) { + auto it = moveOnlyKeys.find(MoveOnly(i + 1)); + ASSERT_FALSE(it == moveOnlyKeys.end()); + ASSERT_EQ(it->value, i + 1); + } + + for (size_t i = 0; i < 100; ++i) + ASSERT_FALSE(moveOnlyKeys.add(MoveOnly(i + 1)).isNewEntry); + + for (size_t i = 0; i < 100; ++i) + ASSERT_EQ(moveOnlyKeys.count(MoveOnly(i + 1)), i + 2); + + for (size_t i = 0; i < 100; ++i) + ASSERT_FALSE(moveOnlyKeys.remove(MoveOnly(i + 1))); + + for (size_t i = 0; i < 100; ++i) + ASSERT_EQ(moveOnlyKeys.count(MoveOnly(i + 1)), i + 1); +} + +TEST(WTF_HashCountedSet, InitializerList) +{ + HashCountedSet<String> hashCountedSet = { + "one", + "two", + "three", + "four", + "four", + "four", + "four", + }; + + EXPECT_EQ(4u, hashCountedSet.size()); + + EXPECT_EQ(hashCountedSet.count("one"), 1u); + EXPECT_EQ(hashCountedSet.count("two"), 1u); + EXPECT_EQ(hashCountedSet.count("three"), 1u); + EXPECT_EQ(hashCountedSet.count("four"), 4u); +} + +TEST(WTF_HashCountedSet, InitializerListInitialCount) +{ + HashCountedSet<String> hashCountedSet = { + { String("one"), 1u }, + { String("two"), 2u }, + { String("three"), 3u }, + { String("four"), 4u }, + }; + + EXPECT_EQ(4u, hashCountedSet.size()); + + EXPECT_EQ(hashCountedSet.count("one"), 1u); + EXPECT_EQ(hashCountedSet.count("two"), 2u); + EXPECT_EQ(hashCountedSet.count("three"), 3u); + EXPECT_EQ(hashCountedSet.count("four"), 4u); +} + +TEST(WTF_HashCountedSet, UniquePtrKey) +{ + ConstructorDestructorCounter::TestingScope scope; + + HashCountedSet<std::unique_ptr<ConstructorDestructorCounter>> hashCountedSet; + + auto uniquePtr = std::make_unique<ConstructorDestructorCounter>(); + hashCountedSet.add(WTFMove(uniquePtr)); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + hashCountedSet.clear(); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); +} + +TEST(WTF_HashCountedSet, UniquePtrKeyInitialCount) +{ + ConstructorDestructorCounter::TestingScope scope; + + HashCountedSet<std::unique_ptr<ConstructorDestructorCounter>> hashCountedSet; + + auto uniquePtr = std::make_unique<ConstructorDestructorCounter>(); + hashCountedSet.add(WTFMove(uniquePtr), 12); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + hashCountedSet.clear(); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); +} + +TEST(WTF_HashCountedSet, UniquePtrKey_CustomDeleter) +{ + ConstructorDestructorCounter::TestingScope constructorDestructorCounterScope; + DeleterCounter<ConstructorDestructorCounter>::TestingScope deleterCounterScope; + + HashCountedSet<std::unique_ptr<ConstructorDestructorCounter, DeleterCounter<ConstructorDestructorCounter>>> hashCountedSet; + + std::unique_ptr<ConstructorDestructorCounter, DeleterCounter<ConstructorDestructorCounter>> uniquePtr(new ConstructorDestructorCounter(), DeleterCounter<ConstructorDestructorCounter>()); + hashCountedSet.add(WTFMove(uniquePtr)); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + EXPECT_EQ(0u, DeleterCounter<ConstructorDestructorCounter>::deleterCount()); + + hashCountedSet.clear(); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); + + EXPECT_EQ(1u, DeleterCounter<ConstructorDestructorCounter>::deleterCount()); +} + +TEST(WTF_HashCountedSet, UniquePtrKey_FindUsingRawPointer) +{ + HashCountedSet<std::unique_ptr<int>> hashCountedSet; + + auto uniquePtr = std::make_unique<int>(5); + int* ptr = uniquePtr.get(); + hashCountedSet.add(WTFMove(uniquePtr)); + + auto it = hashCountedSet.find(ptr); + ASSERT_TRUE(it != hashCountedSet.end()); + EXPECT_EQ(ptr, it->key.get()); + EXPECT_EQ(1u, it->value); +} + +TEST(WTF_HashCountedSet, UniquePtrKey_ContainsUsingRawPointer) +{ + HashCountedSet<std::unique_ptr<int>> hashCountedSet; + + auto uniquePtr = std::make_unique<int>(5); + int* ptr = uniquePtr.get(); + hashCountedSet.add(WTFMove(uniquePtr)); + + EXPECT_EQ(true, hashCountedSet.contains(ptr)); +} + +TEST(WTF_HashCountedSet, UniquePtrKey_GetUsingRawPointer) +{ + HashCountedSet<std::unique_ptr<int>> hashCountedSet; + + auto uniquePtr = std::make_unique<int>(5); + int* ptr = uniquePtr.get(); + hashCountedSet.add(WTFMove(uniquePtr)); + + int value = hashCountedSet.count(ptr); + EXPECT_EQ(1, value); +} + +TEST(WTF_HashCountedSet, UniquePtrKey_RemoveUsingRawPointer) +{ + ConstructorDestructorCounter::TestingScope scope; + + HashCountedSet<std::unique_ptr<ConstructorDestructorCounter>> hashCountedSet; + + auto uniquePtr = std::make_unique<ConstructorDestructorCounter>(); + ConstructorDestructorCounter* ptr = uniquePtr.get(); + hashCountedSet.add(WTFMove(uniquePtr)); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + bool result = hashCountedSet.remove(ptr); + EXPECT_EQ(true, result); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); +} + +TEST(WTF_HashCountedSet, RefPtrKey_Add) +{ + HashCountedSet<RefPtr<RefLogger>> hashCountedSet; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + hashCountedSet.add(ptr); + + ASSERT_STREQ("ref(a) ref(a) ", takeLogStr().c_str()); + EXPECT_EQ(1U, hashCountedSet.count(ptr)); + EXPECT_EQ(1U, hashCountedSet.count(ptr.get())); +} + +TEST(WTF_HashCountedSet, RefPtrKey_AddUsingRelease) +{ + HashCountedSet<RefPtr<RefLogger>> hashCountedSet; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + hashCountedSet.add(WTFMove(ptr)); + + EXPECT_STREQ("ref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashCountedSet, RefPtrKey_AddUsingMove) +{ + HashCountedSet<RefPtr<RefLogger>> hashCountedSet; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + hashCountedSet.add(WTFMove(ptr)); + + EXPECT_STREQ("ref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashCountedSet, RefPtrKey_AddUsingRaw) +{ + HashCountedSet<RefPtr<RefLogger>> hashCountedSet; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + hashCountedSet.add(ptr.get()); + + EXPECT_STREQ("ref(a) ref(a) ", takeLogStr().c_str()); + EXPECT_EQ(1U, hashCountedSet.count(ptr)); + EXPECT_EQ(1U, hashCountedSet.count(ptr.get())); +} + +TEST(WTF_HashCountedSet, RefPtrKey_AddKeyAlreadyPresent) +{ + HashCountedSet<RefPtr<RefLogger>> hashCountedSet; + + DerivedRefLogger a("a"); + + { + RefPtr<RefLogger> ptr(&a); + hashCountedSet.add(ptr); + } + + EXPECT_STREQ("ref(a) ref(a) deref(a) ", takeLogStr().c_str()); + + { + RefPtr<RefLogger> ptr2(&a); + auto addResult = hashCountedSet.add(ptr2); + EXPECT_FALSE(addResult.isNewEntry); + } + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashCountedSet, RefPtrKey_AddUsingReleaseKeyAlreadyPresent) +{ + HashCountedSet<RefPtr<RefLogger>> hashCountedSet; + + DerivedRefLogger a("a"); + + { + RefPtr<RefLogger> ptr(&a); + hashCountedSet.add(ptr); + } + + EXPECT_STREQ("ref(a) ref(a) deref(a) ", takeLogStr().c_str()); + + { + RefPtr<RefLogger> ptr2(&a); + auto addResult = hashCountedSet.add(WTFMove(ptr2)); + EXPECT_FALSE(addResult.isNewEntry); + } + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashCountedSet, RefPtrKey_AddUsingMoveKeyAlreadyPresent) +{ + HashCountedSet<RefPtr<RefLogger>> hashCountedSet; + + DerivedRefLogger a("a"); + + { + RefPtr<RefLogger> ptr(&a); + hashCountedSet.add(ptr); + } + + EXPECT_STREQ("ref(a) ref(a) deref(a) ", takeLogStr().c_str()); + + { + RefPtr<RefLogger> ptr2(&a); + auto addResult = hashCountedSet.add(WTFMove(ptr2)); + EXPECT_FALSE(addResult.isNewEntry); + } + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/HashMap.cpp b/Tools/TestWebKitAPI/Tests/WTF/HashMap.cpp index d03fb9594..222f23c5c 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/HashMap.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/HashMap.cpp @@ -25,9 +25,14 @@ #include "config.h" +#include "Counters.h" +#include "DeletedAddressOfOperator.h" #include "MoveOnly.h" +#include "RefLogger.h" +#include "Test.h" #include <string> #include <wtf/HashMap.h> +#include <wtf/Ref.h> #include <wtf/text/StringHash.h> namespace TestWebKitAPI { @@ -90,7 +95,7 @@ TEST(WTF_HashMap, MoveOnlyValues) for (size_t i = 0; i < 100; ++i) { MoveOnly moveOnly(i + 1); - moveOnlyValues.set(i + 1, std::move(moveOnly)); + moveOnlyValues.set(i + 1, WTFMove(moveOnly)); } for (size_t i = 0; i < 100; ++i) { @@ -113,7 +118,7 @@ TEST(WTF_HashMap, MoveOnlyKeys) for (size_t i = 0; i < 100; ++i) { MoveOnly moveOnly(i + 1); - moveOnlyKeys.set(std::move(moveOnly), i + 1); + moveOnlyKeys.set(WTFMove(moveOnly), i + 1); } for (size_t i = 0; i < 100; ++i) { @@ -139,7 +144,7 @@ TEST(WTF_HashMap, InitializerList) { 4, "four" }, }; - EXPECT_EQ(4, map.size()); + EXPECT_EQ(4u, map.size()); EXPECT_EQ("one", map.get(1)); EXPECT_EQ("two", map.get(2)); @@ -148,4 +153,773 @@ TEST(WTF_HashMap, InitializerList) EXPECT_EQ(std::string(), map.get(5)); } +TEST(WTF_HashMap, EfficientGetter) +{ + HashMap<unsigned, CopyMoveCounter> map; + map.set(1, CopyMoveCounter()); + + { + CopyMoveCounter::TestingScope scope; + map.get(1); + EXPECT_EQ(0U, CopyMoveCounter::constructionCount); + EXPECT_EQ(1U, CopyMoveCounter::copyCount); + EXPECT_EQ(0U, CopyMoveCounter::moveCount); + } + + { + CopyMoveCounter::TestingScope scope; + map.get(2); + EXPECT_EQ(1U, CopyMoveCounter::constructionCount); + EXPECT_EQ(0U, CopyMoveCounter::copyCount); + EXPECT_EQ(1U, CopyMoveCounter::moveCount); + } +} + +TEST(WTF_HashMap, UniquePtrKey) +{ + ConstructorDestructorCounter::TestingScope scope; + + HashMap<std::unique_ptr<ConstructorDestructorCounter>, int> map; + + auto uniquePtr = std::make_unique<ConstructorDestructorCounter>(); + map.add(WTFMove(uniquePtr), 2); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + map.clear(); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); +} + +TEST(WTF_HashMap, UniquePtrKey_CustomDeleter) +{ + ConstructorDestructorCounter::TestingScope constructorDestructorCounterScope; + DeleterCounter<ConstructorDestructorCounter>::TestingScope deleterCounterScope; + + HashMap<std::unique_ptr<ConstructorDestructorCounter, DeleterCounter<ConstructorDestructorCounter>>, int> map; + + std::unique_ptr<ConstructorDestructorCounter, DeleterCounter<ConstructorDestructorCounter>> uniquePtr(new ConstructorDestructorCounter(), DeleterCounter<ConstructorDestructorCounter>()); + map.add(WTFMove(uniquePtr), 2); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + EXPECT_EQ(0u, DeleterCounter<ConstructorDestructorCounter>::deleterCount()); + + map.clear(); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); + + EXPECT_EQ(1u, DeleterCounter<ConstructorDestructorCounter>::deleterCount()); +} + +TEST(WTF_HashMap, UniquePtrKey_FindUsingRawPointer) +{ + HashMap<std::unique_ptr<int>, int> map; + + auto uniquePtr = std::make_unique<int>(5); + int* ptr = uniquePtr.get(); + map.add(WTFMove(uniquePtr), 2); + + auto it = map.find(ptr); + ASSERT_TRUE(it != map.end()); + EXPECT_EQ(ptr, it->key.get()); + EXPECT_EQ(2, it->value); +} + +TEST(WTF_HashMap, UniquePtrKey_ContainsUsingRawPointer) +{ + HashMap<std::unique_ptr<int>, int> map; + + auto uniquePtr = std::make_unique<int>(5); + int* ptr = uniquePtr.get(); + map.add(WTFMove(uniquePtr), 2); + + EXPECT_EQ(true, map.contains(ptr)); +} + +TEST(WTF_HashMap, UniquePtrKey_GetUsingRawPointer) +{ + HashMap<std::unique_ptr<int>, int> map; + + auto uniquePtr = std::make_unique<int>(5); + int* ptr = uniquePtr.get(); + map.add(WTFMove(uniquePtr), 2); + + int value = map.get(ptr); + EXPECT_EQ(2, value); +} + +TEST(WTF_HashMap, UniquePtrKey_RemoveUsingRawPointer) +{ + ConstructorDestructorCounter::TestingScope scope; + + HashMap<std::unique_ptr<ConstructorDestructorCounter>, int> map; + + auto uniquePtr = std::make_unique<ConstructorDestructorCounter>(); + ConstructorDestructorCounter* ptr = uniquePtr.get(); + map.add(WTFMove(uniquePtr), 2); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + bool result = map.remove(ptr); + EXPECT_EQ(true, result); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); +} + +TEST(WTF_HashMap, UniquePtrKey_TakeUsingRawPointer) +{ + ConstructorDestructorCounter::TestingScope scope; + + HashMap<std::unique_ptr<ConstructorDestructorCounter>, int> map; + + auto uniquePtr = std::make_unique<ConstructorDestructorCounter>(); + ConstructorDestructorCounter* ptr = uniquePtr.get(); + map.add(WTFMove(uniquePtr), 2); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + int result = map.take(ptr); + EXPECT_EQ(2, result); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); +} + +TEST(WTF_HashMap, RefPtrKey_Add) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + map.add(ptr, 0); + + ASSERT_STREQ("ref(a) ref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_AddUsingRelease) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + map.add(WTFMove(ptr), 0); + + EXPECT_STREQ("ref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_AddUsingMove) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + map.add(WTFMove(ptr), 0); + + EXPECT_STREQ("ref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_AddUsingRaw) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + map.add(ptr.get(), 0); + + EXPECT_STREQ("ref(a) ref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_AddKeyAlreadyPresent) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + + { + RefPtr<RefLogger> ptr(&a); + map.add(ptr, 0); + } + + EXPECT_STREQ("ref(a) ref(a) deref(a) ", takeLogStr().c_str()); + + { + RefPtr<RefLogger> ptr2(&a); + auto addResult = map.add(ptr2, 0); + EXPECT_FALSE(addResult.isNewEntry); + } + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_AddUsingReleaseKeyAlreadyPresent) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + + { + RefPtr<RefLogger> ptr(&a); + map.add(ptr, 0); + } + + EXPECT_STREQ("ref(a) ref(a) deref(a) ", takeLogStr().c_str()); + + { + RefPtr<RefLogger> ptr2(&a); + auto addResult = map.add(WTFMove(ptr2), 0); + EXPECT_FALSE(addResult.isNewEntry); + } + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_AddUsingMoveKeyAlreadyPresent) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + + { + RefPtr<RefLogger> ptr(&a); + map.add(ptr, 0); + } + + EXPECT_STREQ("ref(a) ref(a) deref(a) ", takeLogStr().c_str()); + + { + RefPtr<RefLogger> ptr2(&a); + auto addResult = map.add(WTFMove(ptr2), 0); + EXPECT_FALSE(addResult.isNewEntry); + } + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_Set) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + map.set(ptr, 0); + + ASSERT_STREQ("ref(a) ref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_SetUsingRelease) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + map.set(WTFMove(ptr), 0); + + EXPECT_STREQ("ref(a) ", takeLogStr().c_str()); +} + + +TEST(WTF_HashMap, RefPtrKey_SetUsingMove) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + map.set(WTFMove(ptr), 0); + + EXPECT_STREQ("ref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_SetUsingRaw) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + RefPtr<RefLogger> ptr(&a); + map.set(ptr.get(), 0); + + EXPECT_STREQ("ref(a) ref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_SetKeyAlreadyPresent) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + + RefPtr<RefLogger> ptr(&a); + map.set(ptr, 0); + + EXPECT_STREQ("ref(a) ref(a) ", takeLogStr().c_str()); + + { + RefPtr<RefLogger> ptr2(&a); + auto addResult = map.set(ptr2, 1); + EXPECT_FALSE(addResult.isNewEntry); + EXPECT_EQ(1, map.get(ptr.get())); + } + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_SetUsingReleaseKeyAlreadyPresent) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + + RefPtr<RefLogger> ptr(&a); + map.set(ptr, 0); + + EXPECT_STREQ("ref(a) ref(a) ", takeLogStr().c_str()); + + { + RefPtr<RefLogger> ptr2(&a); + auto addResult = map.set(WTFMove(ptr2), 1); + EXPECT_FALSE(addResult.isNewEntry); + EXPECT_EQ(1, map.get(ptr.get())); + } + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, RefPtrKey_SetUsingMoveKeyAlreadyPresent) +{ + HashMap<RefPtr<RefLogger>, int> map; + + DerivedRefLogger a("a"); + + RefPtr<RefLogger> ptr(&a); + map.set(ptr, 0); + + EXPECT_STREQ("ref(a) ref(a) ", takeLogStr().c_str()); + + { + RefPtr<RefLogger> ptr2(&a); + auto addResult = map.set(WTFMove(ptr2), 1); + EXPECT_FALSE(addResult.isNewEntry); + EXPECT_EQ(1, map.get(ptr.get())); + } + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, Ensure) +{ + HashMap<unsigned, unsigned> map; + { + auto addResult = map.ensure(1, [] { return 1; }); + EXPECT_EQ(1u, addResult.iterator->value); + EXPECT_EQ(1u, addResult.iterator->key); + EXPECT_TRUE(addResult.isNewEntry); + auto addResult2 = map.ensure(1, [] { return 2; }); + EXPECT_EQ(1u, addResult2.iterator->value); + EXPECT_EQ(1u, addResult2.iterator->key); + EXPECT_FALSE(addResult2.isNewEntry); + } +} + +TEST(WTF_HashMap, Ensure_MoveOnlyValues) +{ + HashMap<unsigned, MoveOnly> moveOnlyValues; + { + auto addResult = moveOnlyValues.ensure(1, [] { return MoveOnly(1); }); + EXPECT_EQ(1u, addResult.iterator->value.value()); + EXPECT_EQ(1u, addResult.iterator->key); + EXPECT_TRUE(addResult.isNewEntry); + auto addResult2 = moveOnlyValues.ensure(1, [] { return MoveOnly(2); }); + EXPECT_EQ(1u, addResult2.iterator->value.value()); + EXPECT_EQ(1u, addResult2.iterator->key); + EXPECT_FALSE(addResult2.isNewEntry); + } +} + +TEST(WTF_HashMap, Ensure_UniquePointer) +{ + HashMap<unsigned, std::unique_ptr<unsigned>> map; + { + auto addResult = map.ensure(1, [] { return std::make_unique<unsigned>(1); }); + EXPECT_EQ(1u, *map.get(1)); + EXPECT_EQ(1u, *addResult.iterator->value.get()); + EXPECT_EQ(1u, addResult.iterator->key); + EXPECT_TRUE(addResult.isNewEntry); + auto addResult2 = map.ensure(1, [] { return std::make_unique<unsigned>(2); }); + EXPECT_EQ(1u, *map.get(1)); + EXPECT_EQ(1u, *addResult2.iterator->value.get()); + EXPECT_EQ(1u, addResult2.iterator->key); + EXPECT_FALSE(addResult2.isNewEntry); + } +} + +TEST(WTF_HashMap, Ensure_RefPtr) +{ + HashMap<unsigned, RefPtr<RefLogger>> map; + + { + DerivedRefLogger a("a"); + + map.ensure(1, [&] { return RefPtr<RefLogger>(&a); }); + EXPECT_STREQ("ref(a) ", takeLogStr().c_str()); + + map.ensure(1, [&] { return RefPtr<RefLogger>(&a); }); + EXPECT_STREQ("", takeLogStr().c_str()); + } +} + +class ObjectWithRefLogger { +public: + ObjectWithRefLogger(Ref<RefLogger>&& logger) + : m_logger(WTFMove(logger)) + { + } + + Ref<RefLogger> m_logger; +}; + + +void testMovingUsingEnsure(Ref<RefLogger>&& logger) +{ + HashMap<unsigned, std::unique_ptr<ObjectWithRefLogger>> map; + + map.ensure(1, [&] { return std::make_unique<ObjectWithRefLogger>(WTFMove(logger)); }); +} + +void testMovingUsingAdd(Ref<RefLogger>&& logger) +{ + HashMap<unsigned, std::unique_ptr<ObjectWithRefLogger>> map; + + auto& slot = map.add(1, nullptr).iterator->value; + slot = std::make_unique<ObjectWithRefLogger>(WTFMove(logger)); +} + +TEST(WTF_HashMap, Ensure_LambdasCapturingByReference) +{ + { + DerivedRefLogger a("a"); + Ref<RefLogger> ref(a); + testMovingUsingEnsure(WTFMove(ref)); + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + } + + { + DerivedRefLogger a("a"); + Ref<RefLogger> ref(a); + testMovingUsingAdd(WTFMove(ref)); + + EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + } +} + + +TEST(WTF_HashMap, ValueIsDestructedOnRemove) +{ + struct DestructorObserver { + DestructorObserver() = default; + + DestructorObserver(bool* destructed) + : destructed(destructed) + { + } + + ~DestructorObserver() + { + if (destructed) + *destructed = true; + } + + DestructorObserver(DestructorObserver&& other) + : destructed(other.destructed) + { + other.destructed = nullptr; + } + + DestructorObserver& operator=(DestructorObserver&& other) + { + destructed = other.destructed; + other.destructed = nullptr; + return *this; + } + + bool* destructed { nullptr }; + }; + + HashMap<int, DestructorObserver> map; + + bool destructed = false; + map.add(5, DestructorObserver { &destructed }); + + EXPECT_FALSE(destructed); + + bool removeResult = map.remove(5); + + EXPECT_TRUE(removeResult); + EXPECT_TRUE(destructed); +} + +TEST(WTF_HashMap, RefPtrNotZeroedBeforeDeref) +{ + struct DerefObserver { + NEVER_INLINE void ref() + { + ++count; + } + NEVER_INLINE void deref() + { + --count; + observedBucket = bucketAddress->get(); + } + unsigned count { 1 }; + const RefPtr<DerefObserver>* bucketAddress { nullptr }; + const DerefObserver* observedBucket { nullptr }; + }; + + auto observer = std::make_unique<DerefObserver>(); + + HashMap<RefPtr<DerefObserver>, int> map; + map.add(adoptRef(observer.get()), 5); + + auto iterator = map.find(observer.get()); + EXPECT_TRUE(iterator != map.end()); + + observer->bucketAddress = &iterator->key; + + EXPECT_TRUE(observer->observedBucket == nullptr); + EXPECT_TRUE(map.remove(observer.get())); + + // It if fine to either leave the old value intact at deletion or already set it to the deleted + // value. + // A zero would be a incorrect outcome as it would mean we nulled the bucket before an opaque + // call. + EXPECT_TRUE(observer->observedBucket == observer.get() || observer->observedBucket == RefPtr<DerefObserver>::hashTableDeletedValue()); + EXPECT_EQ(observer->count, 0u); +} + +TEST(WTF_HashMap, Ref_Key) +{ + { + HashMap<Ref<RefLogger>, int> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.add(WTFMove(ref), 1); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<Ref<RefLogger>, int> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.set(WTFMove(ref), 1); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<Ref<RefLogger>, int> map; + + RefLogger a("a"); + Ref<RefLogger> refA(a); + map.add(WTFMove(refA), 1); + + Ref<RefLogger> refA2(a); + map.set(WTFMove(refA2), 1); + } + + ASSERT_STREQ("ref(a) ref(a) deref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<Ref<RefLogger>, int> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.ensure(WTFMove(ref), []() { + return 1; + }); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<Ref<RefLogger>, int> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.add(WTFMove(ref), 1); + + auto it = map.find(&a); + ASSERT_TRUE(it != map.end()); + + ASSERT_EQ(it->key.ptr(), &a); + ASSERT_EQ(it->value, 1); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<Ref<RefLogger>, int> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.add(WTFMove(ref), 1); + + map.remove(&a); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<Ref<RefLogger>, int> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.add(WTFMove(ref), 1); + + int i = map.take(&a); + ASSERT_EQ(i, 1); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<Ref<RefLogger>, int> map; + for (int i = 0; i < 64; ++i) { + Ref<RefLogger> ref = adoptRef(*new RefLogger("a")); + auto* pointer = ref.ptr(); + map.add(WTFMove(ref), i + 1); + ASSERT_TRUE(map.contains(pointer)); + } + } + + ASSERT_STREQ("deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, Ref_Value) +{ + { + HashMap<int, Ref<RefLogger>> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.add(1, WTFMove(ref)); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<int, Ref<RefLogger>> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.set(1, WTFMove(ref)); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<int, Ref<RefLogger>> map; + + RefLogger a("a"); + Ref<RefLogger> refA(a); + map.add(1, WTFMove(refA)); + + RefLogger b("b"); + Ref<RefLogger> refB(b); + map.set(1, WTFMove(refB)); + } + + ASSERT_STREQ("ref(a) ref(b) deref(a) deref(b) ", takeLogStr().c_str()); + + { + HashMap<int, Ref<RefLogger>> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.add(1, WTFMove(ref)); + + auto aGet = map.get(1); + ASSERT_EQ(aGet, &a); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<int, Ref<RefLogger>> map; + + auto emptyGet = map.get(1); + ASSERT_TRUE(emptyGet == nullptr); + } + + { + HashMap<int, Ref<RefLogger>> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.add(1, WTFMove(ref)); + + auto aOut = map.take(1); + ASSERT_TRUE(static_cast<bool>(aOut)); + ASSERT_EQ(&a, aOut.value().ptr()); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<int, Ref<RefLogger>> map; + + auto emptyTake = map.take(1); + ASSERT_FALSE(static_cast<bool>(emptyTake)); + } + + { + HashMap<int, Ref<RefLogger>> map; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + map.add(1, WTFMove(ref)); + map.remove(1); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<int, Ref<RefLogger>> map; + + RefLogger a("a"); + map.ensure(1, [&]() mutable { + Ref<RefLogger> ref(a); + return ref; + }); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashMap<int, Ref<RefLogger>> map; + for (int i = 0; i < 64; ++i) { + Ref<RefLogger> ref = adoptRef(*new RefLogger("a")); + map.add(i + 1, WTFMove(ref)); + ASSERT_TRUE(map.contains(i + 1)); + } + } + + ASSERT_STREQ("deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashMap, DeletedAddressOfOperator) +{ + HashMap<int, DeletedAddressOfOperator> map1; + for (auto& value : map1.values()) + (void)value; +} + } // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/HashSet.cpp b/Tools/TestWebKitAPI/Tests/WTF/HashSet.cpp index 88e7d075f..3d25057f8 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/HashSet.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/HashSet.cpp @@ -25,9 +25,12 @@ #include "config.h" +#include "Counters.h" +#include "DeletedAddressOfOperator.h" #include "MoveOnly.h" +#include "RefLogger.h" #include <wtf/HashSet.h> - +#include <wtf/RefPtr.h> namespace TestWebKitAPI { @@ -43,7 +46,7 @@ void testInitialCapacity() HashSet<int, DefaultHash<int>::Hash, InitialCapacityTestHashTraits<initialCapacity> > testSet; // Initial capacity is null. - ASSERT_EQ(0, testSet.capacity()); + ASSERT_EQ(0u, testSet.capacity()); // Adding items up to size should never change the capacity. for (size_t i = 0; i < size; ++i) { @@ -84,7 +87,7 @@ TEST(WTF_HashSet, MoveOnly) for (size_t i = 0; i < 100; ++i) { MoveOnly moveOnly(i + 1); - hashSet.add(std::move(moveOnly)); + hashSet.add(WTFMove(moveOnly)); } for (size_t i = 0; i < 100; ++i) @@ -96,11 +99,354 @@ TEST(WTF_HashSet, MoveOnly) EXPECT_TRUE(hashSet.isEmpty()); for (size_t i = 0; i < 100; ++i) - hashSet.add(std::move(MoveOnly(i + 1))); + hashSet.add(MoveOnly(i + 1)); for (size_t i = 0; i < 100; ++i) EXPECT_TRUE(hashSet.take(MoveOnly(i + 1)) == MoveOnly(i + 1)); + EXPECT_TRUE(hashSet.isEmpty()); + + for (size_t i = 0; i < 100; ++i) + hashSet.add(MoveOnly(i + 1)); + + HashSet<MoveOnly> secondSet; + + for (size_t i = 0; i < 100; ++i) + secondSet.add(hashSet.takeAny()); + + EXPECT_TRUE(hashSet.isEmpty()); + + for (size_t i = 0; i < 100; ++i) + EXPECT_TRUE(secondSet.contains(MoveOnly(i + 1))); +} + + +TEST(WTF_HashSet, UniquePtrKey) +{ + ConstructorDestructorCounter::TestingScope scope; + + HashSet<std::unique_ptr<ConstructorDestructorCounter>> set; + + auto uniquePtr = std::make_unique<ConstructorDestructorCounter>(); + set.add(WTFMove(uniquePtr)); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + set.clear(); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); +} + +TEST(WTF_HashSet, UniquePtrKey_FindUsingRawPointer) +{ + HashSet<std::unique_ptr<int>> set; + + auto uniquePtr = std::make_unique<int>(5); + int* ptr = uniquePtr.get(); + set.add(WTFMove(uniquePtr)); + + auto it = set.find(ptr); + ASSERT_TRUE(it != set.end()); + EXPECT_EQ(ptr, it->get()); + EXPECT_EQ(5, *it->get()); +} + +TEST(WTF_HashSet, UniquePtrKey_ContainsUsingRawPointer) +{ + HashSet<std::unique_ptr<int>> set; + + auto uniquePtr = std::make_unique<int>(5); + int* ptr = uniquePtr.get(); + set.add(WTFMove(uniquePtr)); + + EXPECT_EQ(true, set.contains(ptr)); +} + +TEST(WTF_HashSet, UniquePtrKey_RemoveUsingRawPointer) +{ + ConstructorDestructorCounter::TestingScope scope; + + HashSet<std::unique_ptr<ConstructorDestructorCounter>> set; + + auto uniquePtr = std::make_unique<ConstructorDestructorCounter>(); + ConstructorDestructorCounter* ptr = uniquePtr.get(); + set.add(WTFMove(uniquePtr)); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + bool result = set.remove(ptr); + EXPECT_EQ(true, result); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); +} + +TEST(WTF_HashSet, UniquePtrKey_TakeUsingRawPointer) +{ + ConstructorDestructorCounter::TestingScope scope; + + HashSet<std::unique_ptr<ConstructorDestructorCounter>> set; + + auto uniquePtr = std::make_unique<ConstructorDestructorCounter>(); + ConstructorDestructorCounter* ptr = uniquePtr.get(); + set.add(WTFMove(uniquePtr)); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + auto result = set.take(ptr); + EXPECT_EQ(ptr, result.get()); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + + result = nullptr; + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); +} + +TEST(WTF_HashSet, CopyEmpty) +{ + { + HashSet<unsigned> foo; + HashSet<unsigned> bar(foo); + + EXPECT_EQ(0u, bar.capacity()); + EXPECT_EQ(0u, bar.size()); + } + { + HashSet<unsigned> foo({ 1, 5, 64, 42 }); + EXPECT_EQ(4u, foo.size()); + foo.remove(1); + foo.remove(5); + foo.remove(42); + foo.remove(64); + HashSet<unsigned> bar(foo); + + EXPECT_EQ(0u, bar.capacity()); + EXPECT_EQ(0u, bar.size()); + } +} + +TEST(WTF_HashSet, CopyAllocateAtLeastMinimumCapacity) +{ + HashSet<unsigned> foo({ 42 }); + EXPECT_EQ(1u, foo.size()); + HashSet<unsigned> bar(foo); + + EXPECT_EQ(8u, bar.capacity()); + EXPECT_EQ(1u, bar.size()); +} + +TEST(WTF_HashSet, CopyCapacityIsNotOnBoundary) +{ + // Starting at 4 because the minimum size is 8. + // With a size of 8, a medium load can be up to 3.3333->3. + // Adding 1 to 3 would reach max load. + // While correct, that's not really what we care about here. + for (unsigned size = 4; size < 100; ++size) { + HashSet<unsigned> source; + for (unsigned i = 1; i < size + 1; ++i) + source.add(i); + + HashSet<unsigned> copy1(source); + HashSet<unsigned> copy2(source); + HashSet<unsigned> copy3(source); + + EXPECT_EQ(size, copy1.size()); + EXPECT_EQ(size, copy2.size()); + EXPECT_EQ(size, copy3.size()); + for (unsigned i = 1; i < size + 1; ++i) { + EXPECT_TRUE(copy1.contains(i)); + EXPECT_TRUE(copy2.contains(i)); + EXPECT_TRUE(copy3.contains(i)); + } + EXPECT_FALSE(copy1.contains(size + 2)); + EXPECT_FALSE(copy2.contains(size + 2)); + EXPECT_FALSE(copy3.contains(size + 2)); + + EXPECT_TRUE(copy2.remove(1)); + EXPECT_EQ(copy1.capacity(), copy2.capacity()); + EXPECT_FALSE(copy2.contains(1)); + + EXPECT_TRUE(copy3.add(size + 2).isNewEntry); + EXPECT_EQ(copy1.capacity(), copy3.capacity()); + EXPECT_TRUE(copy3.contains(size + 2)); + } +} + +TEST(WTF_HashSet, RefPtrNotZeroedBeforeDeref) +{ + struct DerefObserver { + NEVER_INLINE void ref() + { + ++count; + } + NEVER_INLINE void deref() + { + --count; + observedBucket = bucketAddress->get(); + } + unsigned count { 1 }; + const RefPtr<DerefObserver>* bucketAddress { nullptr }; + const DerefObserver* observedBucket { nullptr }; + }; + + auto observer = std::make_unique<DerefObserver>(); + + HashSet<RefPtr<DerefObserver>> set; + set.add(adoptRef(observer.get())); + + auto iterator = set.find(observer.get()); + EXPECT_TRUE(iterator != set.end()); + + observer->bucketAddress = iterator.get(); + + EXPECT_TRUE(observer->observedBucket == nullptr); + EXPECT_TRUE(set.remove(observer.get())); + + // It if fine to either leave the old value intact at deletion or already set it to the deleted + // value. + // A zero would be a incorrect outcome as it would mean we nulled the bucket before an opaque + // call. + EXPECT_TRUE(observer->observedBucket == observer.get() || observer->observedBucket == RefPtr<DerefObserver>::hashTableDeletedValue()); + EXPECT_EQ(observer->count, 0u); +} + + +TEST(WTF_HashSet, UniquePtrNotZeroedBeforeDestructor) +{ + struct DestructorObserver { + ~DestructorObserver() + { + observe(); + } + std::function<void()> observe; + }; + + const std::unique_ptr<DestructorObserver>* bucketAddress = nullptr; + const DestructorObserver* observedBucket = nullptr; + std::unique_ptr<DestructorObserver> observer(new DestructorObserver { [&]() { + observedBucket = bucketAddress->get(); + }}); + + const DestructorObserver* observerAddress = observer.get(); + + HashSet<std::unique_ptr<DestructorObserver>> set; + auto addResult = set.add(WTFMove(observer)); + + EXPECT_TRUE(addResult.isNewEntry); + EXPECT_TRUE(observedBucket == nullptr); + + bucketAddress = addResult.iterator.get(); + + EXPECT_TRUE(observedBucket == nullptr); + EXPECT_TRUE(set.remove(*addResult.iterator)); + + EXPECT_TRUE(observedBucket == observerAddress || observedBucket == reinterpret_cast<const DestructorObserver*>(-1)); +} + +TEST(WTF_HashSet, Ref) +{ + { + HashSet<Ref<RefLogger>> set; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + set.add(WTFMove(ref)); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashSet<Ref<RefLogger>> set; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + set.add(ref.copyRef()); + } + + ASSERT_STREQ("ref(a) ref(a) deref(a) deref(a) ", takeLogStr().c_str()); + + { + HashSet<Ref<RefLogger>> set; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + set.add(WTFMove(ref)); + set.remove(&a); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashSet<Ref<RefLogger>> set; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + set.add(WTFMove(ref)); + + auto aOut = set.take(&a); + ASSERT_TRUE(static_cast<bool>(aOut)); + ASSERT_EQ(&a, aOut.value().ptr()); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashSet<Ref<RefLogger>> set; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + set.add(WTFMove(ref)); + + auto aOut = set.takeAny(); + ASSERT_TRUE(static_cast<bool>(aOut)); + ASSERT_EQ(&a, aOut.value().ptr()); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashSet<Ref<RefLogger>> set; + auto emptyTake = set.takeAny(); + ASSERT_FALSE(static_cast<bool>(emptyTake)); + } + + { + HashSet<Ref<RefLogger>> set; + + RefLogger a("a"); + Ref<RefLogger> ref(a); + set.add(WTFMove(ref)); + + ASSERT_TRUE(set.contains(&a)); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + HashSet<Ref<RefLogger>> set; + for (int i = 0; i < 64; ++i) { + Ref<RefLogger> ref = adoptRef(*new RefLogger("a")); + auto* pointer = ref.ptr(); + set.add(WTFMove(ref)); + ASSERT_TRUE(set.contains(pointer)); + } + } + ASSERT_STREQ("deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_HashSet, DeletedAddressOfOperator) +{ + HashSet<DeletedAddressOfOperator> set1; + set1.add(10); + + set1.remove(10); } } // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/LEBDecoder.cpp b/Tools/TestWebKitAPI/Tests/WTF/LEBDecoder.cpp new file mode 100644 index 000000000..2141080c4 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/LEBDecoder.cpp @@ -0,0 +1,241 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <wtf/LEBDecoder.h> +#include <wtf/Vector.h> + +namespace TestWebKitAPI { + +static void testUInt32LEBDecode(std::initializer_list<uint8_t> data, size_t startOffset, bool expectedStatus, uint32_t expectedResult, size_t expectedOffset) +{ + Vector<uint8_t> vector(data); + uint32_t result; + bool status = WTF::LEBDecoder::decodeUInt32(vector.data(), vector.size(), startOffset, result); + EXPECT_EQ(expectedStatus, status); + if (expectedStatus) { + EXPECT_EQ(expectedResult, result); + EXPECT_EQ(expectedOffset, startOffset); + } +} + +TEST(WTF, LEBDecoderUInt32) +{ + // Simple tests that use all the bits in the array + testUInt32LEBDecode({ 0x07 }, 0, true, 0x7lu, 1lu); + testUInt32LEBDecode({ 0x77 }, 0, true, 0x77lu, 1lu); + testUInt32LEBDecode({ 0x80, 0x07 }, 0, true, 0x380lu, 2lu); + testUInt32LEBDecode({ 0x89, 0x12 }, 0, true, 0x909lu, 2lu); + testUInt32LEBDecode({ 0xf3, 0x85, 0x02 }, 0, true, 0x82f3lu, 3lu); + testUInt32LEBDecode({ 0xf3, 0x85, 0xff, 0x74 }, 0, true, 0xe9fc2f3lu, 4lu); + testUInt32LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0x7f }, 0, true, 0xfe9fc2f3lu, 5lu); + // Test with extra trailing numbers + testUInt32LEBDecode({ 0x07, 0x80 }, 0, true, 0x7lu, 1lu); + testUInt32LEBDecode({ 0x07, 0x75 }, 0, true, 0x7lu, 1lu); + testUInt32LEBDecode({ 0xf3, 0x85, 0xff, 0x74, 0x43 }, 0, true, 0xe9fc2f3lu, 4lu); + testUInt32LEBDecode({ 0xf3, 0x85, 0xff, 0x74, 0x80 }, 0, true, 0xe9fc2f3lu, 4lu); + // Test with preceeding numbers + testUInt32LEBDecode({ 0xf3, 0x07 }, 1, true, 0x7lu, 2lu); + testUInt32LEBDecode({ 0x03, 0x07 }, 1, true, 0x7lu, 2lu); + testUInt32LEBDecode({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77 }, 5, true, 0x77lu, 6lu); + testUInt32LEBDecode({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77 }, 5, true, 0x77lu, 6ul); + testUInt32LEBDecode({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02 }, 3, true, 0x82f3lu, 6lu); + // Test in the middle + testUInt32LEBDecode({ 0xf3, 0x07, 0x89 }, 1, true, 0x7lu, 2lu); + testUInt32LEBDecode({ 0x03, 0x07, 0x23 }, 1, true, 0x7lu, 2lu); + testUInt32LEBDecode({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77, 0x43 }, 5, true, 0x77lu, 6lu); + testUInt32LEBDecode({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77, 0xf9 }, 5, true, 0x77lu, 6lu); + testUInt32LEBDecode({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02, 0xa4 }, 3, true, 0x82f3lu, 6lu); + // Test decode too long + testUInt32LEBDecode({ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 }, 0, false, 0x0lu, 0lu); + testUInt32LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 1, false, 0x0lu, 0lu); + testUInt32LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 0, false, 0x0lu, 0lu); + // Test decode off end of array + testUInt32LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 2, false, 0x0lu, 0lu); +} + +static void testUInt64LEBDecode(std::initializer_list<uint8_t> data, size_t startOffset, bool expectedStatus, uint64_t expectedResult, size_t expectedOffset) +{ + Vector<uint8_t> vector(data); + uint64_t result; + bool status = WTF::LEBDecoder::decodeUInt64(vector.data(), vector.size(), startOffset, result); + EXPECT_EQ(expectedStatus, status); + if (expectedStatus) { + EXPECT_EQ(expectedResult, result); + EXPECT_EQ(expectedOffset, startOffset); + } +} + +TEST(WTF, LEBDecoderUInt64) +{ + // Simple tests that use all the bits in the array + testUInt64LEBDecode({ 0x07 }, 0, true, 0x7lu, 1lu); + testUInt64LEBDecode({ 0x77 }, 0, true, 0x77lu, 1lu); + testUInt64LEBDecode({ 0x80, 0x07 }, 0, true, 0x380lu, 2lu); + testUInt64LEBDecode({ 0x89, 0x12 }, 0, true, 0x909lu, 2lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0x02 }, 0, true, 0x82f3lu, 3lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0x74 }, 0, true, 0xe9fc2f3lu, 4lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0x7f }, 0, true, 0x7fe9fc2f3lu, 5lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0xff, 0x4b }, 0, true, 0x25ffe9fc2f3lu, 6lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0x3a }, 0, true, 0xea5ffe9fc2f3lu, 7lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0xba, 0x0f }, 0, true, 0x1eea5ffe9fc2f3lu, 8lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0xba, 0x8f, 0x69 }, 0, true, 0x691eea5ffe9fc2f3lu, 9lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0xba, 0x8f, 0xe9, 0x01 }, 0, true, 0xe91eea5ffe9fc2f3lu, 10lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0xba, 0x8f, 0xe9, 0x70 }, 0, true, 0x691eea5ffe9fc2f3lu, 10lu); + // Test with extra trailing numbers + testUInt64LEBDecode({ 0x07, 0x80 }, 0, true, 0x7lu, 1lu); + testUInt64LEBDecode({ 0x07, 0x75 }, 0, true, 0x7lu, 1lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0x74, 0x43 }, 0, true, 0xe9fc2f3lu, 4lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0x74, 0x80 }, 0, true, 0xe9fc2f3lu, 4lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0xba, 0x8f, 0x69, 0x45 }, 0, true, 0x691eea5ffe9fc2f3lu, 9lu); + // Test with preceeding numbers + testUInt64LEBDecode({ 0xf3, 0x07 }, 1, true, 0x7lu, 2lu); + testUInt64LEBDecode({ 0x03, 0x07 }, 1, true, 0x7lu, 2lu); + testUInt64LEBDecode({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77 }, 5, true, 0x77lu, 6lu); + testUInt64LEBDecode({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77 }, 5, true, 0x77lu, 6ul); + testUInt64LEBDecode({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02 }, 3, true, 0x82f3lu, 6lu); + testUInt64LEBDecode({ 0x92, 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0xba, 0x8f, 0x69 }, 1, true, 0x691eea5ffe9fc2f3lu, 10lu); + // Test in the middle + testUInt64LEBDecode({ 0xf3, 0x07, 0x89 }, 1, true, 0x7lu, 2lu); + testUInt64LEBDecode({ 0x03, 0x07, 0x23 }, 1, true, 0x7lu, 2lu); + testUInt64LEBDecode({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77, 0x43 }, 5, true, 0x77lu, 6lu); + testUInt64LEBDecode({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77, 0xf9 }, 5, true, 0x77lu, 6lu); + testUInt64LEBDecode({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02, 0xa4 }, 3, true, 0x82f3lu, 6lu); + testUInt64LEBDecode({ 0x92, 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0xba, 0x8f, 0x69, 0x85, 0x75 }, 1, true, 0x691eea5ffe9fc2f3lu, 10lu); + testUInt64LEBDecode({ 0x92, 0x65, 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0xba, 0x8f, 0x69, 0x85, 0x75 }, 2, true, 0x691eea5ffe9fc2f3lu, 11lu); + // Test decode too long + testUInt64LEBDecode({ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 }, 0, false, 0x0lu, 0lu); + testUInt64LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xa3, 0x9f, 0xd2, 0xef, 0x8a, 0x4e }, 1, false, 0x0lu, 0lu); + testUInt64LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff, 0xef, 0xd8, 0xee, 0xaa, 0xbb }, 0, false, 0x0lu, 0lu); + testUInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0xba, 0x8f, 0xa9, 0xa8, 0x05 }, 0, false, 0x0lu, 0lu); + // Test decode off end of array + testUInt64LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 2, false, 0x0lu, 0lu); + testUInt64LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 2, false, 0x0lu, 0lu); + testUInt64LEBDecode({ 0x92, 0xf3, 0x85, 0xff, 0xf4, 0xff, 0xcb, 0xba, 0x8f }, 1, false, 0x0lu, 0lu); +} + +static void testInt32LEBDecode(std::initializer_list<uint8_t> data, size_t startOffset, bool expectedStatus, int32_t expectedResult, size_t expectedOffset) +{ + Vector<uint8_t> vector(data); + int32_t result; + bool status = WTF::LEBDecoder::decodeInt32(vector.data(), vector.size(), startOffset, result); + EXPECT_EQ(expectedStatus, status); + if (expectedStatus) { + EXPECT_EQ(expectedResult, result); + EXPECT_EQ(expectedOffset, startOffset); + } +} + +TEST(WTF, LEBDecoderInt32) +{ + // Simple tests that use all the bits in the array + testInt32LEBDecode({ 0x07 }, 0, true, 0x7, 1lu); + testInt32LEBDecode({ 0x77 }, 0, true, -0x9, 1lu); + testInt32LEBDecode({ 0x80, 0x07 }, 0, true, 0x380, 2lu); + testInt32LEBDecode({ 0x89, 0x12 }, 0, true, 0x909, 2lu); + testInt32LEBDecode({ 0xf3, 0x85, 0x02 }, 0, true, 0x82f3, 3lu); + testInt32LEBDecode({ 0xf3, 0x85, 0xff, 0x74 }, 0, true, 0xfe9fc2f3, 4lu); + testInt32LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0x7f }, 0, true, 0xfe9fc2f3, 5lu); + // Test with extra trailing numbers + testInt32LEBDecode({ 0x07, 0x80 }, 0, true, 0x7, 1lu); + testInt32LEBDecode({ 0x07, 0x75 }, 0, true, 0x7, 1lu); + testInt32LEBDecode({ 0xf3, 0x85, 0xff, 0x74, 0x43 }, 0, true, 0xfe9fc2f3, 4lu); + testInt32LEBDecode({ 0xf3, 0x85, 0xff, 0x74, 0x80 }, 0, true, 0xfe9fc2f3, 4lu); + // Test with preceeding numbers + testInt32LEBDecode({ 0xf3, 0x07 }, 1, true, 0x7, 2lu); + testInt32LEBDecode({ 0x03, 0x07 }, 1, true, 0x7, 2lu); + testInt32LEBDecode({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77 }, 5, true, -0x9, 6lu); + testInt32LEBDecode({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77 }, 5, true, -0x9, 6lu); + testInt32LEBDecode({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02 }, 3, true, 0x82f3, 6lu); + // Test in the middle + testInt32LEBDecode({ 0xf3, 0x07, 0x89 }, 1, true, 0x7, 2lu); + testInt32LEBDecode({ 0x03, 0x07, 0x23 }, 1, true, 0x7, 2lu); + testInt32LEBDecode({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77, 0x43 }, 5, true, -0x9, 6lu); + testInt32LEBDecode({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77, 0xf9 }, 5, true, -0x9, 6lu); + testInt32LEBDecode({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02, 0xa4 }, 3, true, 0x82f3, 6lu); + // Test decode too long + testInt32LEBDecode({ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 }, 0, false, 0x0, 0lu); + testInt32LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 1, false, 0x0, 0lu); + testInt32LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 0, false, 0x0, 0lu); + // Test decode off end of array + testInt32LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 2, false, 0x0, 0lu); +} + +static void testInt64LEBDecode(std::initializer_list<uint8_t> data, size_t startOffset, bool expectedStatus, int64_t expectedResult, size_t expectedOffset) +{ + Vector<uint8_t> vector(data); + int64_t result; + bool status = WTF::LEBDecoder::decodeInt64(vector.data(), vector.size(), startOffset, result); + EXPECT_EQ(expectedStatus, status); + if (expectedStatus) { + EXPECT_EQ(expectedResult, result); + EXPECT_EQ(expectedOffset, startOffset); + } +} + +TEST(WTF, LEBDecoderInt64) +{ + // Simple tests that use all the bits in the array + testInt64LEBDecode({ 0x07 }, 0, true, 0x7, 1lu); + testInt64LEBDecode({ 0x77 }, 0, true, -0x9, 1lu); + testInt64LEBDecode({ 0x80, 0x07 }, 0, true, 0x380, 2lu); + testInt64LEBDecode({ 0x89, 0x12 }, 0, true, 0x909, 2lu); + testInt64LEBDecode({ 0xf3, 0x85, 0x02 }, 0, true, 0x82f3, 3lu); + testInt64LEBDecode({ 0xf3, 0x85, 0xff, 0x74 }, 0, true, 0xfffffffffe9fc2f3, 4lu); + testInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0x7f }, 0, true, 0xfffffffffe9fc2f3, 5lu); + testInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0x3f }, 0, true, 0x3fe9fc2f3, 5lu); + testInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0x8f, 0x1a }, 0, true, 0xd0fe9fc2f3, 6lu); + testInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0x8f, 0x9a, 0x80, 0x2a }, 0, true, 0x5400d0fe9fc2f3, 8lu); + testInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0x8f, 0x9a, 0x80, 0xaa, 0x41 }, 0, true, 0xc15400d0fe9fc2f3, 9lu); + testInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0x8f, 0x9a, 0x80, 0xaa, 0xc1, 0x01 }, 0, true, 0xc15400d0fe9fc2f3, 10lu); + testInt64LEBDecode({ 0xf3, 0x85, 0xff, 0xf4, 0x8f, 0x9a, 0x80, 0xaa, 0xc1, 0x62 }, 0, true, 0x415400d0fe9fc2f3, 10lu); + // Test with extra trailing numbers + testInt64LEBDecode({ 0x07, 0x80 }, 0, true, 0x7, 1lu); + testInt64LEBDecode({ 0x07, 0x75 }, 0, true, 0x7, 1lu); + testInt64LEBDecode({ 0xf3, 0x85, 0xff, 0x74, 0x43 }, 0, true, 0xfffffffffe9fc2f3, 4lu); + testInt64LEBDecode({ 0xf3, 0x85, 0xff, 0x74, 0x80 }, 0, true, 0xfffffffffe9fc2f3, 4lu); + // Test with preceeding numbers + testInt64LEBDecode({ 0xf3, 0x07 }, 1, true, 0x7, 2lu); + testInt64LEBDecode({ 0x03, 0x07 }, 1, true, 0x7, 2lu); + testInt64LEBDecode({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77 }, 5, true, -0x9, 6lu); + testInt64LEBDecode({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77 }, 5, true, -0x9, 6lu); + testInt64LEBDecode({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02 }, 3, true, 0x82f3, 6lu); + // Test in the middle + testInt64LEBDecode({ 0xf3, 0x07, 0x89 }, 1, true, 0x7, 2lu); + testInt64LEBDecode({ 0x03, 0x07, 0x23 }, 1, true, 0x7, 2lu); + testInt64LEBDecode({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77, 0x43 }, 5, true, -0x9, 6lu); + testInt64LEBDecode({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77, 0xf9 }, 5, true, -0x9, 6lu); + testInt64LEBDecode({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02, 0xa4 }, 3, true, 0x82f3, 6lu); + // Test decode too long + testInt64LEBDecode({ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 }, 0, false, 0x0, 0lu); + testInt64LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 1, false, 0x0, 0lu); + testInt64LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 0, false, 0x0, 0lu); + // Test decode off end of array + testInt64LEBDecode({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff }, 2, false, 0x0, 0lu); +} + + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/ListHashSet.cpp b/Tools/TestWebKitAPI/Tests/WTF/ListHashSet.cpp index a550a845b..b97d866e7 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/ListHashSet.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/ListHashSet.cpp @@ -78,7 +78,7 @@ TEST(WTF_ListHashSet, AppendOrMoveToLastNewItems) result = list.appendOrMoveToLast(3); ASSERT_TRUE(result.isNewEntry); - ASSERT_EQ(list.size(), 3); + ASSERT_EQ(list.size(), 3u); // The list should be in order 1, 2, 3. ListHashSet<int>::iterator iterator = list.begin(); @@ -99,11 +99,11 @@ TEST(WTF_ListHashSet, AppendOrMoveToLastWithDuplicates) ASSERT_TRUE(result.isNewEntry); result = list.appendOrMoveToLast(1); ASSERT_FALSE(result.isNewEntry); - ASSERT_EQ(1, list.size()); + ASSERT_EQ(1u, list.size()); list.add(2); list.add(3); - ASSERT_EQ(3, list.size()); + ASSERT_EQ(3u, list.size()); // Appending 2 move it to the end. ASSERT_EQ(3, list.last()); @@ -118,7 +118,7 @@ TEST(WTF_ListHashSet, AppendOrMoveToLastWithDuplicates) ASSERT_FALSE(result.isNewEntry); result = list.appendOrMoveToLast(1); ASSERT_FALSE(result.isNewEntry); - ASSERT_EQ(3, list.size()); + ASSERT_EQ(3u, list.size()); ListHashSet<int>::iterator iterator = list.begin(); ASSERT_EQ(3, *iterator); @@ -139,7 +139,7 @@ TEST(WTF_ListHashSet, PrependOrMoveToLastNewItems) result = list.prependOrMoveToFirst(3); ASSERT_TRUE(result.isNewEntry); - ASSERT_EQ(list.size(), 3); + ASSERT_EQ(list.size(), 3u); // The list should be in order 3, 1, 2. ListHashSet<int>::iterator iterator = list.begin(); @@ -160,11 +160,11 @@ TEST(WTF_ListHashSet, PrependOrMoveToLastWithDuplicates) ASSERT_TRUE(result.isNewEntry); result = list.prependOrMoveToFirst(1); ASSERT_FALSE(result.isNewEntry); - ASSERT_EQ(1, list.size()); + ASSERT_EQ(1u, list.size()); list.add(2); list.add(3); - ASSERT_EQ(3, list.size()); + ASSERT_EQ(3u, list.size()); // Prepending 2 move it to the beginning. ASSERT_EQ(1, list.first()); @@ -179,7 +179,7 @@ TEST(WTF_ListHashSet, PrependOrMoveToLastWithDuplicates) ASSERT_FALSE(result.isNewEntry); result = list.prependOrMoveToFirst(3); ASSERT_FALSE(result.isNewEntry); - ASSERT_EQ(3, list.size()); + ASSERT_EQ(3u, list.size()); ListHashSet<int>::iterator iterator = list.begin(); ASSERT_EQ(3, *iterator); @@ -266,4 +266,86 @@ TEST(WTF_ListHashSet, MoveOnly) ASSERT_TRUE(list.isEmpty()); } +TEST(WTF_ListHashSet, MoveConstructor) +{ + ListHashSet<int> list; + list.add(1); + list.add(2); + list.add(3); + + ASSERT_EQ(3U, list.size()); + auto iterator = list.begin(); + ASSERT_EQ(1, *iterator); + ++iterator; + ASSERT_EQ(2, *iterator); + ++iterator; + ASSERT_EQ(3, *iterator); + ++iterator; + + ListHashSet<int> list2(WTFMove(list)); + ASSERT_EQ(3U, list2.size()); + auto iterator2 = list2.begin(); + ASSERT_EQ(1, *iterator2); + ++iterator2; + ASSERT_EQ(2, *iterator2); + ++iterator2; + ASSERT_EQ(3, *iterator2); + ++iterator2; + + ASSERT_EQ(0U, list.size()); + ASSERT_TRUE(list.begin() == list.end()); + list.add(4); + list.add(5); + list.add(6); + iterator = list.begin(); + ASSERT_EQ(4, *iterator); + ++iterator; + ASSERT_EQ(5, *iterator); + ++iterator; + ASSERT_EQ(6, *iterator); + ++iterator; +} + +TEST(WTF_ListHashSet, MoveAssignment) +{ + ListHashSet<int> list; + list.add(1); + list.add(2); + list.add(3); + + ASSERT_EQ(3U, list.size()); + auto iterator = list.begin(); + ASSERT_EQ(1, *iterator); + ++iterator; + ASSERT_EQ(2, *iterator); + ++iterator; + ASSERT_EQ(3, *iterator); + ++iterator; + + ListHashSet<int> list2; + list2.add(10); + list2 = (WTFMove(list)); + ASSERT_EQ(3U, list2.size()); + auto iterator2 = list2.begin(); + ASSERT_EQ(1, *iterator2); + ++iterator2; + ASSERT_EQ(2, *iterator2); + ++iterator2; + ASSERT_EQ(3, *iterator2); + ++iterator2; + + ASSERT_EQ(0U, list.size()); + ASSERT_TRUE(list.begin() == list.end()); + list.add(4); + list.add(5); + list.add(6); + iterator = list.begin(); + ASSERT_EQ(4, *iterator); + ++iterator; + ASSERT_EQ(5, *iterator); + ++iterator; + ASSERT_EQ(6, *iterator); + ++iterator; +} + } // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/Lock.cpp b/Tools/TestWebKitAPI/Tests/WTF/Lock.cpp new file mode 100644 index 000000000..5576302d6 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/Lock.cpp @@ -0,0 +1,189 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include <wtf/Lock.h> +#include <wtf/Threading.h> +#include <wtf/ThreadingPrimitives.h> +#include <wtf/WordLock.h> + +using namespace WTF; + +namespace TestWebKitAPI { + +struct LockInspector { + template<typename LockType> + static bool isFullyReset(LockType& lock) + { + return lock.isFullyReset(); + } +}; + +template<typename LockType> +void runLockTest(unsigned numThreadGroups, unsigned numThreadsPerGroup, unsigned workPerCriticalSection, unsigned numIterations) +{ + std::unique_ptr<LockType[]> locks = std::make_unique<LockType[]>(numThreadGroups); + std::unique_ptr<double[]> words = std::make_unique<double[]>(numThreadGroups); + std::unique_ptr<ThreadIdentifier[]> threads = std::make_unique<ThreadIdentifier[]>(numThreadGroups * numThreadsPerGroup); + + for (unsigned threadGroupIndex = numThreadGroups; threadGroupIndex--;) { + words[threadGroupIndex] = 0; + + for (unsigned threadIndex = numThreadsPerGroup; threadIndex--;) { + threads[threadGroupIndex * numThreadsPerGroup + threadIndex] = createThread( + "Lock test thread", + [threadGroupIndex, &locks, &words, numIterations, workPerCriticalSection] () { + for (unsigned i = numIterations; i--;) { + locks[threadGroupIndex].lock(); + for (unsigned j = workPerCriticalSection; j--;) + words[threadGroupIndex]++; + locks[threadGroupIndex].unlock(); + } + }); + } + } + + for (unsigned threadIndex = numThreadGroups * numThreadsPerGroup; threadIndex--;) + waitForThreadCompletion(threads[threadIndex]); + + double expected = 0; + for (uint64_t i = static_cast<uint64_t>(numIterations) * workPerCriticalSection * numThreadsPerGroup; i--;) + expected++; + + for (unsigned threadGroupIndex = numThreadGroups; threadGroupIndex--;) + EXPECT_EQ(expected, words[threadGroupIndex]); + + // Now test that the locks correctly reset themselves. We expect that if a single thread locks + // each of the locks twice in a row, then the lock should be in a pristine state. + for (unsigned threadGroupIndex = numThreadGroups; threadGroupIndex--;) { + for (unsigned i = 2; i--;) { + locks[threadGroupIndex].lock(); + locks[threadGroupIndex].unlock(); + } + + EXPECT_EQ(true, LockInspector::isFullyReset(locks[threadGroupIndex])); + } +} + +bool skipSlow() +{ +#if PLATFORM(WIN) && !defined(NDEBUG) + return true; +#else + return false; +#endif +} + +TEST(WTF_WordLock, UncontendedShortSection) +{ + runLockTest<WordLock>(1, 1, 1, 10000000); +} + +TEST(WTF_WordLock, UncontendedLongSection) +{ + runLockTest<WordLock>(1, 1, 10000, 1000); +} + +TEST(WTF_WordLock, ContendedShortSection) +{ + if (skipSlow()) + return; + runLockTest<WordLock>(1, 10, 1, 5000000); +} + +TEST(WTF_WordLock, ContendedLongSection) +{ + if (skipSlow()) + return; + runLockTest<WordLock>(1, 10, 10000, 10000); +} + +TEST(WTF_WordLock, ManyContendedShortSections) +{ + if (skipSlow()) + return; + runLockTest<WordLock>(10, 10, 1, 500000); +} + +TEST(WTF_WordLock, ManyContendedLongSections) +{ + if (skipSlow()) + return; + runLockTest<WordLock>(10, 10, 10000, 500); +} + +TEST(WTF_Lock, UncontendedShortSection) +{ + runLockTest<Lock>(1, 1, 1, 10000000); +} + +TEST(WTF_Lock, UncontendedLongSection) +{ + runLockTest<Lock>(1, 1, 10000, 1000); +} + +TEST(WTF_Lock, ContendedShortSection) +{ + if (skipSlow()) + return; + runLockTest<Lock>(1, 10, 1, 10000000); +} + +TEST(WTF_Lock, ContendedLongSection) +{ + if (skipSlow()) + return; + runLockTest<Lock>(1, 10, 10000, 10000); +} + +TEST(WTF_Lock, ManyContendedShortSections) +{ + if (skipSlow()) + return; + runLockTest<Lock>(10, 10, 1, 500000); +} + +TEST(WTF_Lock, ManyContendedLongSections) +{ + if (skipSlow()) + return; + runLockTest<Lock>(10, 10, 10000, 1000); +} + +TEST(WTF_Lock, ManyContendedLongerSections) +{ + if (skipSlow()) + return; + runLockTest<Lock>(10, 10, 100000, 1); +} + +TEST(WTF_Lock, SectionAddressCollision) +{ + if (skipSlow()) + return; + runLockTest<Lock>(4, 2, 10000, 2000); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/MediaTime.cpp b/Tools/TestWebKitAPI/Tests/WTF/MediaTime.cpp index 8e9b178af..ac8bb1c3a 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/MediaTime.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/MediaTime.cpp @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -26,24 +26,14 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#define _USE_MATH_DEFINES 1 #include "config.h" +#include <limits> +#include <wtf/MathExtras.h> #include <wtf/MediaTime.h> using namespace std; -#if COMPILER(MSVC) -// Work around Visual Studio 2008's lack of an INFINITY or NAN definition. -#include <limits> -#if !defined(INFINITY) -#define INFINITY (numeric_limits<double>::infinity()) -#endif -#if !defined(NAN) -#define NAN (numeric_limits<double>::quiet_NaN()) -#endif -#endif - namespace WTF { std::ostream& operator<<(std::ostream& out, const MediaTime& val) @@ -55,6 +45,8 @@ std::ostream& operator<<(std::ostream& out, const MediaTime& val) out << "+infinite"; else if (val.isNegativeInfinite()) out << "-infinite"; + else if (val.hasDoubleValue()) + out << "double: " << val.toDouble(); else out << "value: " << val.timeValue() << ", scale: " << val.timeScale(); return out << " }"; @@ -93,6 +85,8 @@ TEST(WTF, MediaTime) EXPECT_EQ(MediaTime(1, 1) != MediaTime(2, 1), true); EXPECT_EQ(MediaTime(2, 1) == MediaTime(2, 1), true); EXPECT_EQ(MediaTime(2, 1) == MediaTime(4, 2), true); + EXPECT_TRUE((bool)MediaTime(1, 1)); + EXPECT_TRUE(!MediaTime(0, 1)); // Addition Operators EXPECT_EQ(MediaTime::positiveInfiniteTime() + MediaTime::positiveInfiniteTime(), MediaTime::positiveInfiniteTime()); @@ -166,8 +160,6 @@ TEST(WTF, MediaTime) EXPECT_EQ(abs(MediaTime::invalidTime()), MediaTime::invalidTime()); EXPECT_EQ(abs(MediaTime(1, 1)), MediaTime(1, 1)); EXPECT_EQ(abs(MediaTime(-1, 1)), MediaTime(1, 1)); - EXPECT_EQ(abs(MediaTime(-1, -1)), MediaTime(-1, -1)); - EXPECT_EQ(abs(MediaTime(1, -1)), MediaTime(-1, -1)); // Floating Point Functions EXPECT_EQ(MediaTime::createWithFloat(1.0f), MediaTime(1, 1)); @@ -180,25 +172,42 @@ TEST(WTF, MediaTime) EXPECT_EQ(MediaTime(3, 2).toDouble(), 1.5); EXPECT_EQ(MediaTime(1, 1 << 16).toFloat(), 1 / pow(2.0f, 16.0f)); EXPECT_EQ(MediaTime(1, 1 << 30).toDouble(), 1 / pow(2.0, 30.0)); - EXPECT_EQ(MediaTime::createWithDouble(M_PI, 1 << 30), MediaTime(3373259426U, 1 << 30)); - EXPECT_EQ(MediaTime::createWithFloat(INFINITY), MediaTime::positiveInfiniteTime()); - EXPECT_EQ(MediaTime::createWithFloat(-INFINITY), MediaTime::negativeInfiniteTime()); - EXPECT_EQ(MediaTime::createWithFloat(NAN), MediaTime::invalidTime()); - EXPECT_EQ(MediaTime::createWithDouble(INFINITY), MediaTime::positiveInfiniteTime()); - EXPECT_EQ(MediaTime::createWithDouble(-INFINITY), MediaTime::negativeInfiniteTime()); - EXPECT_EQ(MediaTime::createWithDouble(NAN), MediaTime::invalidTime()); + EXPECT_EQ(MediaTime::createWithDouble(piDouble, 1 << 30), MediaTime(3373259426U, 1 << 30)); + + EXPECT_EQ(MediaTime::createWithFloat(std::numeric_limits<float>::infinity()), MediaTime::positiveInfiniteTime()); + EXPECT_EQ(MediaTime::createWithFloat(-std::numeric_limits<float>::infinity()), MediaTime::negativeInfiniteTime()); + EXPECT_EQ(MediaTime::createWithFloat(std::numeric_limits<float>::quiet_NaN()), MediaTime::invalidTime()); + + EXPECT_EQ(MediaTime::createWithDouble(std::numeric_limits<double>::infinity()), MediaTime::positiveInfiniteTime()); + EXPECT_EQ(MediaTime::createWithDouble(-std::numeric_limits<double>::infinity()), MediaTime::negativeInfiniteTime()); + EXPECT_EQ(MediaTime::createWithDouble(std::numeric_limits<double>::quiet_NaN()), MediaTime::invalidTime()); + + // Floating Point Round Trip + EXPECT_EQ(10.0123456789f, MediaTime::createWithFloat(10.0123456789f).toFloat()); + EXPECT_EQ(10.0123456789, MediaTime::createWithDouble(10.0123456789).toDouble()); + EXPECT_EQ(MediaTime(1, 3), MediaTime::createWithDouble(MediaTime(1, 3).toDouble())); + + // Floating Point Math + EXPECT_EQ(1.5 + 3.3, (MediaTime::createWithDouble(1.5) + MediaTime::createWithDouble(3.3)).toDouble()); + EXPECT_EQ(1.5 - 3.3, (MediaTime::createWithDouble(1.5) - MediaTime::createWithDouble(3.3)).toDouble()); + EXPECT_EQ(-3.3, (-MediaTime::createWithDouble(3.3)).toDouble()); + EXPECT_EQ(3.3 * 2, (MediaTime::createWithDouble(3.3) * 2).toDouble()); + + // Floating Point and non-Floating Point math + EXPECT_EQ(2.0, (MediaTime::createWithDouble(1.5) + MediaTime(1, 2)).toDouble()); + EXPECT_EQ(1.0, (MediaTime::createWithDouble(1.5) - MediaTime(1, 2)).toDouble()); // Overflow Behavior EXPECT_EQ(MediaTime::createWithFloat(pow(2.0f, 64.0f)), MediaTime::positiveInfiniteTime()); EXPECT_EQ(MediaTime::createWithFloat(-pow(2.0f, 64.0f)), MediaTime::negativeInfiniteTime()); - EXPECT_EQ(MediaTime::createWithFloat(pow(2.0f, 63.0f), 2).timeScale(), 1); - EXPECT_EQ(MediaTime::createWithFloat(pow(2.0f, 63.0f), 3).timeScale(), 1); + EXPECT_EQ(MediaTime::createWithFloat(pow(2.0f, 63.0f), 2).timeScale(), 1U); + EXPECT_EQ(MediaTime::createWithFloat(pow(2.0f, 63.0f), 3).timeScale(), 1U); EXPECT_EQ(MediaTime::createWithDouble(pow(2.0, 64.0)), MediaTime::positiveInfiniteTime()); EXPECT_EQ(MediaTime::createWithDouble(-pow(2.0, 64.0)), MediaTime::negativeInfiniteTime()); - EXPECT_EQ(MediaTime::createWithDouble(pow(2.0, 63.0), 2).timeScale(), 1); - EXPECT_EQ(MediaTime::createWithDouble(pow(2.0, 63.0), 3).timeScale(), 1); - EXPECT_EQ((MediaTime(numeric_limits<int64_t>::max(), 2) + MediaTime(numeric_limits<int64_t>::max(), 2)).timeScale(), 1); - EXPECT_EQ((MediaTime(numeric_limits<int64_t>::min(), 2) - MediaTime(numeric_limits<int64_t>::max(), 2)).timeScale(), 1); + EXPECT_EQ(MediaTime::createWithDouble(pow(2.0, 63.0), 2).timeScale(), 1U); + EXPECT_EQ(MediaTime::createWithDouble(pow(2.0, 63.0), 3).timeScale(), 1U); + EXPECT_EQ((MediaTime(numeric_limits<int64_t>::max(), 2) + MediaTime(numeric_limits<int64_t>::max(), 2)).timeScale(), 1U); + EXPECT_EQ((MediaTime(numeric_limits<int64_t>::min(), 2) - MediaTime(numeric_limits<int64_t>::max(), 2)).timeScale(), 1U); EXPECT_EQ(MediaTime(numeric_limits<int64_t>::max(), 1) + MediaTime(numeric_limits<int64_t>::max(), 1), MediaTime::positiveInfiniteTime()); EXPECT_EQ(MediaTime(numeric_limits<int64_t>::min(), 1) + MediaTime(numeric_limits<int64_t>::min(), 1), MediaTime::negativeInfiniteTime()); EXPECT_EQ(MediaTime(numeric_limits<int64_t>::min(), 1) - MediaTime(numeric_limits<int64_t>::max(), 1), MediaTime::negativeInfiniteTime()); diff --git a/Tools/TestWebKitAPI/Tests/WTF/MetaAllocator.cpp b/Tools/TestWebKitAPI/Tests/WTF/MetaAllocator.cpp index 61c16d1ab..59af4f849 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/MetaAllocator.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/MetaAllocator.cpp @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * @@ -31,6 +31,10 @@ #include <wtf/MetaAllocator.h> #include <wtf/Vector.h> +#if OS(WINDOWS) +#undef small +#endif + using namespace WTF; namespace TestWebKitAPI { diff --git a/Tools/TestWebKitAPI/Tests/WTF/NakedPtr.cpp b/Tools/TestWebKitAPI/Tests/WTF/NakedPtr.cpp new file mode 100644 index 000000000..f4b4836cd --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/NakedPtr.cpp @@ -0,0 +1,238 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "RefLogger.h" +#include <wtf/NakedPtr.h> + +namespace TestWebKitAPI { + +// For these tests, we need a base class and a derived class. For this purpose, +// we reuse the RefLogger and DerivedRefLogger classes. + +TEST(WTF_NakedPtr, Basic) +{ + DerivedRefLogger a("a"); + + NakedPtr<RefLogger> empty; + ASSERT_EQ(nullptr, empty.get()); + + { + NakedPtr<RefLogger> ptr(&a); + ASSERT_EQ(&a, ptr.get()); + ASSERT_EQ(&a, &*ptr); + ASSERT_EQ(&a.name, &ptr->name); + } + + { + NakedPtr<RefLogger> ptr = &a; + ASSERT_EQ(&a, ptr.get()); + } + + { + NakedPtr<RefLogger> p1 = &a; + NakedPtr<RefLogger> p2(p1); + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&a, p2.get()); + } + + { + NakedPtr<RefLogger> p1 = &a; + NakedPtr<RefLogger> p2 = p1; + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&a, p2.get()); + } + + { + NakedPtr<RefLogger> p1 = &a; + NakedPtr<RefLogger> p2 = WTFMove(p1); + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&a, p2.get()); + } + + { + NakedPtr<RefLogger> p1 = &a; + NakedPtr<RefLogger> p2(WTFMove(p1)); + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&a, p2.get()); + } + + { + NakedPtr<DerivedRefLogger> p1 = &a; + NakedPtr<RefLogger> p2 = p1; + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&a, p2.get()); + } + + { + NakedPtr<DerivedRefLogger> p1 = &a; + NakedPtr<RefLogger> p2 = WTFMove(p1); + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&a, p2.get()); + } + + { + NakedPtr<RefLogger> ptr(&a); + ASSERT_EQ(&a, ptr.get()); + ptr.clear(); + ASSERT_EQ(nullptr, ptr.get()); + } +} + +TEST(WTF_NakedPtr, Assignment) +{ + DerivedRefLogger a("a"); + RefLogger b("b"); + DerivedRefLogger c("c"); + + { + NakedPtr<RefLogger> p1(&a); + NakedPtr<RefLogger> p2(&b); + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&b, p2.get()); + p1 = p2; + ASSERT_EQ(&b, p1.get()); + ASSERT_EQ(&b, p2.get()); + } + + { + NakedPtr<RefLogger> ptr(&a); + ASSERT_EQ(&a, ptr.get()); + ptr = &b; + ASSERT_EQ(&b, ptr.get()); + } + + { + NakedPtr<RefLogger> ptr(&a); + ASSERT_EQ(&a, ptr.get()); + ptr = nullptr; + ASSERT_EQ(nullptr, ptr.get()); + } + + { + NakedPtr<RefLogger> p1(&a); + NakedPtr<RefLogger> p2(&b); + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&b, p2.get()); + p1 = WTFMove(p2); + ASSERT_EQ(&b, p1.get()); + ASSERT_EQ(&b, p2.get()); + } + + { + NakedPtr<RefLogger> p1(&a); + NakedPtr<DerivedRefLogger> p2(&c); + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&c, p2.get()); + p1 = p2; + ASSERT_EQ(&c, p1.get()); + ASSERT_EQ(&c, p2.get()); + } + + { + NakedPtr<RefLogger> ptr(&a); + ASSERT_EQ(&a, ptr.get()); + ptr = &c; + ASSERT_EQ(&c, ptr.get()); + } + + { + NakedPtr<RefLogger> p1(&a); + NakedPtr<DerivedRefLogger> p2(&c); + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&c, p2.get()); + p1 = WTFMove(p2); + ASSERT_EQ(&c, p1.get()); + ASSERT_EQ(&c, p2.get()); + } + + { + NakedPtr<RefLogger> ptr(&a); + ASSERT_EQ(&a, ptr.get()); + ptr = ptr; + ASSERT_EQ(&a, ptr.get()); + } + + { + NakedPtr<RefLogger> ptr(&a); + ASSERT_EQ(&a, ptr.get()); +#if COMPILER(CLANG) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunknown-pragmas" +#pragma clang diagnostic ignored "-Wself-move" +#endif + ptr = WTFMove(ptr); +#if COMPILER(CLANG) +#pragma clang diagnostic pop +#endif + ASSERT_EQ(&a, ptr.get()); + } +} + +TEST(WTF_NakedPtr, Swap) +{ + RefLogger a("a"); + RefLogger b("b"); + + { + NakedPtr<RefLogger> p1(&a); + NakedPtr<RefLogger> p2(&b); + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&b, p2.get()); + p1.swap(p2); + ASSERT_EQ(&b, p1.get()); + ASSERT_EQ(&a, p2.get()); + } + + { + NakedPtr<RefLogger> p1(&a); + NakedPtr<RefLogger> p2(&b); + ASSERT_EQ(&a, p1.get()); + ASSERT_EQ(&b, p2.get()); + std::swap(p1, p2); + ASSERT_EQ(&b, p1.get()); + ASSERT_EQ(&a, p2.get()); + } +} + +NakedPtr<RefLogger> nakedPtrFoo(RefLogger& logger) +{ + return NakedPtr<RefLogger>(&logger); +} + +TEST(WTF_NakedPtr, ReturnValue) +{ + DerivedRefLogger a("a"); + + { + auto ptr = nakedPtrFoo(a); + ASSERT_EQ(&a, ptr.get()); + ASSERT_EQ(&a, &*ptr); + ASSERT_EQ(&a.name, &ptr->name); + } +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/OptionSet.cpp b/Tools/TestWebKitAPI/Tests/WTF/OptionSet.cpp new file mode 100644 index 000000000..f0173831b --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/OptionSet.cpp @@ -0,0 +1,297 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "Test.h" +#include <wtf/OptionSet.h> + +namespace TestWebKitAPI { + +enum class ExampleFlags : uint64_t { + A = 1 << 0, + B = 1 << 1, + C = 1 << 2, + D = 1ULL << 31, + E = 1ULL << 63, +}; + +TEST(WTF_OptionSet, EmptySet) +{ + OptionSet<ExampleFlags> set; + EXPECT_TRUE(set.isEmpty()); + EXPECT_FALSE(set.contains(ExampleFlags::A)); + EXPECT_FALSE(set.contains(ExampleFlags::B)); + EXPECT_FALSE(set.contains(ExampleFlags::C)); + EXPECT_FALSE(set.contains(ExampleFlags::D)); + EXPECT_FALSE(set.contains(ExampleFlags::E)); +} + +TEST(WTF_OptionSet, ContainsOneFlag) +{ + OptionSet<ExampleFlags> set = ExampleFlags::A; + EXPECT_FALSE(set.isEmpty()); + EXPECT_TRUE(set.contains(ExampleFlags::A)); + EXPECT_FALSE(set.contains(ExampleFlags::B)); + EXPECT_FALSE(set.contains(ExampleFlags::C)); + EXPECT_FALSE(set.contains(ExampleFlags::D)); + EXPECT_FALSE(set.contains(ExampleFlags::E)); +} + +TEST(WTF_OptionSet, Equal) +{ + OptionSet<ExampleFlags> set { ExampleFlags::A, ExampleFlags::B }; + + EXPECT_TRUE((set == OptionSet<ExampleFlags> { ExampleFlags::A, ExampleFlags::B })); + EXPECT_TRUE((set == OptionSet<ExampleFlags> { ExampleFlags::B, ExampleFlags::A })); + EXPECT_FALSE(set == ExampleFlags::B); +} + +TEST(WTF_OptionSet, NotEqual) +{ + OptionSet<ExampleFlags> set = ExampleFlags::A; + + EXPECT_TRUE(set != ExampleFlags::B); + EXPECT_FALSE(set != ExampleFlags::A); +} + +TEST(WTF_OptionSet, Minus) +{ + OptionSet<ExampleFlags> set { ExampleFlags::A, ExampleFlags::B, ExampleFlags::C }; + + EXPECT_TRUE(((set - ExampleFlags::A) == OptionSet<ExampleFlags> { ExampleFlags::B, ExampleFlags::C })); + EXPECT_TRUE(((set - ExampleFlags::D) == OptionSet<ExampleFlags> { ExampleFlags::A, ExampleFlags::B, ExampleFlags::C })); + EXPECT_TRUE((set - set).isEmpty()); +} + +TEST(WTF_OptionSet, ContainsTwoFlags) +{ + OptionSet<ExampleFlags> set { ExampleFlags::A, ExampleFlags::B }; + EXPECT_FALSE(set.isEmpty()); + EXPECT_TRUE(set.contains(ExampleFlags::A)); + EXPECT_TRUE(set.contains(ExampleFlags::B)); + EXPECT_FALSE(set.contains(ExampleFlags::C)); + EXPECT_FALSE(set.contains(ExampleFlags::D)); + EXPECT_FALSE(set.contains(ExampleFlags::E)); +} + +TEST(WTF_OptionSet, ContainsTwoFlags2) +{ + OptionSet<ExampleFlags> set { ExampleFlags::A, ExampleFlags::D }; + EXPECT_FALSE(set.isEmpty()); + EXPECT_TRUE(set.contains(ExampleFlags::A)); + EXPECT_TRUE(set.contains(ExampleFlags::D)); + EXPECT_FALSE(set.contains(ExampleFlags::B)); + EXPECT_FALSE(set.contains(ExampleFlags::C)); + EXPECT_FALSE(set.contains(ExampleFlags::E)); +} + +TEST(WTF_OptionSet, ContainsTwoFlags3) +{ + OptionSet<ExampleFlags> set { ExampleFlags::D, ExampleFlags::E }; + EXPECT_FALSE(set.isEmpty()); + EXPECT_TRUE(set.contains(ExampleFlags::D)); + EXPECT_TRUE(set.contains(ExampleFlags::E)); + EXPECT_FALSE(set.contains(ExampleFlags::A)); + EXPECT_FALSE(set.contains(ExampleFlags::B)); + EXPECT_FALSE(set.contains(ExampleFlags::C)); +} + +TEST(WTF_OptionSet, OperatorBitwiseOr) +{ + OptionSet<ExampleFlags> set = ExampleFlags::A; + set |= ExampleFlags::C; + EXPECT_TRUE(set.contains(ExampleFlags::A)); + EXPECT_FALSE(set.contains(ExampleFlags::B)); + EXPECT_TRUE(set.contains(ExampleFlags::C)); +} + +TEST(WTF_OptionSet, EmptyOptionSetToRawValueToOptionSet) +{ + OptionSet<ExampleFlags> set; + EXPECT_TRUE(set.isEmpty()); + EXPECT_FALSE(set.contains(ExampleFlags::A)); + EXPECT_FALSE(set.contains(ExampleFlags::B)); + EXPECT_FALSE(set.contains(ExampleFlags::C)); + + auto set2 = OptionSet<ExampleFlags>::fromRaw(set.toRaw()); + EXPECT_TRUE(set2.isEmpty()); + EXPECT_FALSE(set2.contains(ExampleFlags::A)); + EXPECT_FALSE(set2.contains(ExampleFlags::B)); + EXPECT_FALSE(set2.contains(ExampleFlags::C)); +} + +TEST(WTF_OptionSet, OptionSetThatContainsOneFlagToRawValueToOptionSet) +{ + OptionSet<ExampleFlags> set = ExampleFlags::A; + EXPECT_FALSE(set.isEmpty()); + EXPECT_TRUE(set.contains(ExampleFlags::A)); + EXPECT_FALSE(set.contains(ExampleFlags::B)); + EXPECT_FALSE(set.contains(ExampleFlags::C)); + EXPECT_FALSE(set.contains(ExampleFlags::D)); + EXPECT_FALSE(set.contains(ExampleFlags::E)); + + auto set2 = OptionSet<ExampleFlags>::fromRaw(set.toRaw()); + EXPECT_FALSE(set2.isEmpty()); + EXPECT_TRUE(set2.contains(ExampleFlags::A)); + EXPECT_FALSE(set2.contains(ExampleFlags::B)); + EXPECT_FALSE(set2.contains(ExampleFlags::C)); + EXPECT_FALSE(set2.contains(ExampleFlags::D)); + EXPECT_FALSE(set2.contains(ExampleFlags::E)); +} + +TEST(WTF_OptionSet, OptionSetThatContainsOneFlagToRawValueToOptionSet2) +{ + OptionSet<ExampleFlags> set = ExampleFlags::E; + EXPECT_FALSE(set.isEmpty()); + EXPECT_TRUE(set.contains(ExampleFlags::E)); + EXPECT_FALSE(set.contains(ExampleFlags::A)); + EXPECT_FALSE(set.contains(ExampleFlags::B)); + EXPECT_FALSE(set.contains(ExampleFlags::C)); + EXPECT_FALSE(set.contains(ExampleFlags::D)); + + auto set2 = OptionSet<ExampleFlags>::fromRaw(set.toRaw()); + EXPECT_FALSE(set2.isEmpty()); + EXPECT_TRUE(set2.contains(ExampleFlags::E)); + EXPECT_FALSE(set2.contains(ExampleFlags::A)); + EXPECT_FALSE(set2.contains(ExampleFlags::B)); + EXPECT_FALSE(set2.contains(ExampleFlags::C)); + EXPECT_FALSE(set2.contains(ExampleFlags::D)); +} + +TEST(WTF_OptionSet, OptionSetThatContainsTwoFlagsToRawValueToOptionSet) +{ + OptionSet<ExampleFlags> set { ExampleFlags::A, ExampleFlags::C }; + EXPECT_FALSE(set.isEmpty()); + EXPECT_TRUE(set.contains(ExampleFlags::A)); + EXPECT_TRUE(set.contains(ExampleFlags::C)); + EXPECT_FALSE(set.contains(ExampleFlags::B)); + + auto set2 = OptionSet<ExampleFlags>::fromRaw(set.toRaw()); + EXPECT_FALSE(set2.isEmpty()); + EXPECT_TRUE(set2.contains(ExampleFlags::A)); + EXPECT_TRUE(set2.contains(ExampleFlags::C)); + EXPECT_FALSE(set2.contains(ExampleFlags::B)); +} + +TEST(WTF_OptionSet, OptionSetThatContainsTwoFlagsToRawValueToOptionSet2) +{ + OptionSet<ExampleFlags> set { ExampleFlags::D, ExampleFlags::E }; + EXPECT_FALSE(set.isEmpty()); + EXPECT_TRUE(set.contains(ExampleFlags::D)); + EXPECT_TRUE(set.contains(ExampleFlags::E)); + EXPECT_FALSE(set.contains(ExampleFlags::A)); + EXPECT_FALSE(set.contains(ExampleFlags::B)); + EXPECT_FALSE(set.contains(ExampleFlags::C)); + + auto set2 = OptionSet<ExampleFlags>::fromRaw(set.toRaw()); + EXPECT_FALSE(set2.isEmpty()); + EXPECT_TRUE(set2.contains(ExampleFlags::D)); + EXPECT_TRUE(set2.contains(ExampleFlags::E)); + EXPECT_FALSE(set2.contains(ExampleFlags::A)); + EXPECT_FALSE(set2.contains(ExampleFlags::B)); + EXPECT_FALSE(set2.contains(ExampleFlags::C)); +} + +TEST(WTF_OptionSet, TwoIteratorsIntoSameOptionSet) +{ + OptionSet<ExampleFlags> set { ExampleFlags::C, ExampleFlags::B }; + OptionSet<ExampleFlags>::iterator it1 = set.begin(); + OptionSet<ExampleFlags>::iterator it2 = it1; + ++it1; + EXPECT_STRONG_ENUM_EQ(ExampleFlags::C, *it1); + EXPECT_STRONG_ENUM_EQ(ExampleFlags::B, *it2); +} + +TEST(WTF_OptionSet, IterateOverOptionSetThatContainsTwoFlags) +{ + OptionSet<ExampleFlags> set { ExampleFlags::A, ExampleFlags::C }; + OptionSet<ExampleFlags>::iterator it = set.begin(); + OptionSet<ExampleFlags>::iterator end = set.end(); + EXPECT_TRUE(it != end); + EXPECT_STRONG_ENUM_EQ(ExampleFlags::A, *it); + ++it; + EXPECT_STRONG_ENUM_EQ(ExampleFlags::C, *it); + ++it; + EXPECT_TRUE(it == end); +} + +TEST(WTF_OptionSet, IterateOverOptionSetThatContainsFlags2) +{ + OptionSet<ExampleFlags> set { ExampleFlags::D, ExampleFlags::E }; + OptionSet<ExampleFlags>::iterator it = set.begin(); + OptionSet<ExampleFlags>::iterator end = set.end(); + EXPECT_TRUE(it != end); + EXPECT_STRONG_ENUM_EQ(ExampleFlags::D, *it); + ++it; + EXPECT_STRONG_ENUM_EQ(ExampleFlags::E, *it); + ++it; + EXPECT_TRUE(it == end); +} + +TEST(WTF_OptionSet, NextItemAfterLargestIn32BitFlagSet) +{ + enum class ThirtyTwoBitFlags : uint32_t { + A = 1UL << 31, + }; + OptionSet<ThirtyTwoBitFlags> set { ThirtyTwoBitFlags::A }; + OptionSet<ThirtyTwoBitFlags>::iterator it = set.begin(); + OptionSet<ThirtyTwoBitFlags>::iterator end = set.end(); + EXPECT_TRUE(it != end); + ++it; + EXPECT_TRUE(it == end); +} + +TEST(WTF_OptionSet, NextItemAfterLargestIn64BitFlagSet) +{ + enum class SixtyFourBitFlags : uint64_t { + A = 1ULL << 63, + }; + OptionSet<SixtyFourBitFlags> set { SixtyFourBitFlags::A }; + OptionSet<SixtyFourBitFlags>::iterator it = set.begin(); + OptionSet<SixtyFourBitFlags>::iterator end = set.end(); + EXPECT_TRUE(it != end); + ++it; + EXPECT_TRUE(it == end); +} + +TEST(WTF_OptionSet, IterationOrderTheSameRegardlessOfInsertionOrder) +{ + OptionSet<ExampleFlags> set1 = ExampleFlags::C; + set1 |= ExampleFlags::A; + + OptionSet<ExampleFlags> set2 = ExampleFlags::A; + set2 |= ExampleFlags::C; + + OptionSet<ExampleFlags>::iterator it1 = set1.begin(); + OptionSet<ExampleFlags>::iterator it2 = set2.begin(); + + EXPECT_TRUE(*it1 == *it2); + ++it1; + ++it2; + EXPECT_TRUE(*it1 == *it2); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/Optional.cpp b/Tools/TestWebKitAPI/Tests/WTF/Optional.cpp new file mode 100644 index 000000000..a70881f35 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/Optional.cpp @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2014 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <wtf/Optional.h> + +namespace TestWebKitAPI { + +TEST(WTF_Optional, Disengaged) +{ + { + std::optional<int> optional; + + EXPECT_FALSE(static_cast<bool>(optional)); + } + + { + std::optional<int> optional { std::nullopt }; + + EXPECT_FALSE(static_cast<bool>(optional)); + } +} + +TEST(WTF_Optional, Engaged) +{ + std::optional<int> optional { 10 }; + + EXPECT_TRUE(static_cast<bool>(optional)); + EXPECT_EQ(10, optional.value()); +} + +TEST(WTF_Optional, Destructor) +{ + static bool didCallDestructor = false; + struct A { + ~A() + { + EXPECT_FALSE(didCallDestructor); + didCallDestructor = true; + } + }; + + { + std::optional<A> optional { std::in_place }; + + EXPECT_TRUE(static_cast<bool>(optional)); + } + + EXPECT_TRUE(didCallDestructor); +} + +TEST(WTF_Optional, Callback) +{ + bool called = false; + std::optional<int> a; + int result = valueOrCompute(a, [&] { + called = true; + return 300; + }); + EXPECT_TRUE(called); + EXPECT_EQ(result, 300); + + a = 250; + called = false; + result = valueOrCompute(a, [&] { + called = true; + return 300; + }); + EXPECT_FALSE(called); + EXPECT_EQ(result, 250); +} + +TEST(WTF_Optional, Equality) +{ + std::optional<int> unengaged1; + std::optional<int> unengaged2; + + std::optional<int> engaged1 { 1 }; + std::optional<int> engaged2 { 2 }; + std::optional<int> engagedx2 { 2 }; + + EXPECT_TRUE(unengaged1 == unengaged2); + EXPECT_FALSE(engaged1 == engaged2); + EXPECT_FALSE(engaged1 == unengaged1); + EXPECT_TRUE(engaged2 == engagedx2); + + EXPECT_TRUE(unengaged1 == std::nullopt); + EXPECT_FALSE(engaged1 == std::nullopt); + EXPECT_TRUE(std::nullopt == unengaged1); + EXPECT_FALSE(std::nullopt == engaged1); + + EXPECT_TRUE(engaged1 == 1); + EXPECT_TRUE(1 == engaged1); + EXPECT_FALSE(unengaged1 == 1); + EXPECT_FALSE(1 == unengaged1); +} + +TEST(WTF_Optional, Inequality) +{ + std::optional<int> unengaged1; + std::optional<int> unengaged2; + + std::optional<int> engaged1 { 1 }; + std::optional<int> engaged2 { 2 }; + std::optional<int> engagedx2 { 2 }; + + EXPECT_FALSE(unengaged1 != unengaged2); + EXPECT_TRUE(engaged1 != engaged2); + EXPECT_TRUE(engaged1 != unengaged1); + EXPECT_FALSE(engaged2 != engagedx2); + + EXPECT_FALSE(unengaged1 != std::nullopt); + EXPECT_TRUE(engaged1 != std::nullopt); + EXPECT_FALSE(std::nullopt != unengaged1); + EXPECT_TRUE(std::nullopt != engaged1); + + EXPECT_FALSE(engaged1 != 1); + EXPECT_TRUE(engaged1 != 2); + EXPECT_FALSE(1 != engaged1); + EXPECT_TRUE(2 != engaged1); + + EXPECT_TRUE(unengaged1 != 1); + EXPECT_TRUE(1 != unengaged1); +} + + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/ParkingLot.cpp b/Tools/TestWebKitAPI/Tests/WTF/ParkingLot.cpp new file mode 100644 index 000000000..c67e1e081 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/ParkingLot.cpp @@ -0,0 +1,273 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include <condition_variable> +#include <mutex> +#include <thread> +#include <wtf/DataLog.h> +#include <wtf/HashSet.h> +#include <wtf/ListDump.h> +#include <wtf/ParkingLot.h> +#include <wtf/Threading.h> +#include <wtf/ThreadingPrimitives.h> + +using namespace WTF; + +namespace TestWebKitAPI { + +namespace { + +struct SingleLatchTest { + void initialize(unsigned numThreads) + { + // This implements a fair (FIFO) semaphore, and it starts out unavailable. + semaphore.store(0); + + for (unsigned i = numThreads; i--;) { + threads.append( + createThread( + "Parking Test Thread", + [&] () { + EXPECT_NE(0u, currentThread()); + + down(); + + std::lock_guard<std::mutex> locker(lock); + awake.add(currentThread()); + lastAwoken = currentThread(); + condition.notify_one(); + })); + } + } + + void unparkOne(unsigned singleUnparkIndex) + { + EXPECT_EQ(0u, lastAwoken); + + unsigned numWaitingOnAddress = 0; + Vector<ThreadIdentifier, 8> queue; + ParkingLot::forEach( + [&] (ThreadIdentifier threadIdentifier, const void* address) { + if (address != &semaphore) + return; + + queue.append(threadIdentifier); + + numWaitingOnAddress++; + }); + + EXPECT_LE(numWaitingOnAddress, threads.size() - singleUnparkIndex); + + up(); + + { + std::unique_lock<std::mutex> locker(lock); + while (awake.size() < singleUnparkIndex + 1) + condition.wait(locker); + EXPECT_NE(0u, lastAwoken); + if (!queue.isEmpty() && queue[0] != lastAwoken) { + dataLog("Woke up wrong thread: queue = ", listDump(queue), ", last awoken = ", lastAwoken, "\n"); + EXPECT_EQ(queue[0], lastAwoken); + } + lastAwoken = 0; + } + } + + void finish(unsigned numSingleUnparks) + { + unsigned numWaitingOnAddress = 0; + ParkingLot::forEach( + [&] (ThreadIdentifier, const void* address) { + if (address != &semaphore) + return; + + numWaitingOnAddress++; + }); + + EXPECT_LE(numWaitingOnAddress, threads.size() - numSingleUnparks); + + semaphore.store(threads.size() - numSingleUnparks); + ParkingLot::unparkAll(&semaphore); + + numWaitingOnAddress = 0; + ParkingLot::forEach( + [&] (ThreadIdentifier, const void* address) { + if (address != &semaphore) + return; + + numWaitingOnAddress++; + }); + + EXPECT_EQ(0u, numWaitingOnAddress); + + { + std::unique_lock<std::mutex> locker(lock); + while (awake.size() < threads.size()) + condition.wait(locker); + } + + for (ThreadIdentifier threadIdentifier : threads) + waitForThreadCompletion(threadIdentifier); + } + + // Semaphore operations. + void down() + { + for (;;) { + int oldSemaphoreValue = semaphore.load(); + int newSemaphoreValue = oldSemaphoreValue - 1; + if (!semaphore.compareExchangeWeak(oldSemaphoreValue, newSemaphoreValue)) + continue; + + if (oldSemaphoreValue > 0) { + // We acquired the semaphore. Done. + return; + } + + // We need to wait. + if (ParkingLot::compareAndPark(&semaphore, newSemaphoreValue).wasUnparked) { + // We did wait, and then got woken up. This means that someone who up'd the semaphore + // passed ownership onto us. + return; + } + + // We never parked, because the semaphore value changed. Undo our decrement and try again. + for (;;) { + int oldSemaphoreValue = semaphore.load(); + if (semaphore.compareExchangeWeak(oldSemaphoreValue, oldSemaphoreValue + 1)) + break; + } + } + } + void up() + { + int oldSemaphoreValue; + for (;;) { + oldSemaphoreValue = semaphore.load(); + if (semaphore.compareExchangeWeak(oldSemaphoreValue, oldSemaphoreValue + 1)) + break; + } + + // Check if anyone was waiting on the semaphore. If they were, then pass ownership to them. + if (oldSemaphoreValue < 0) + ParkingLot::unparkOne(&semaphore); + } + + Atomic<int> semaphore; + std::mutex lock; + std::condition_variable condition; + HashSet<ThreadIdentifier> awake; + Vector<ThreadIdentifier> threads; + ThreadIdentifier lastAwoken { 0 }; +}; + +void runParkingTest(unsigned numLatches, unsigned delay, unsigned numThreads, unsigned numSingleUnparks) +{ + std::unique_ptr<SingleLatchTest[]> tests = std::make_unique<SingleLatchTest[]>(numLatches); + + for (unsigned latchIndex = numLatches; latchIndex--;) + tests[latchIndex].initialize(numThreads); + + for (unsigned unparkIndex = 0; unparkIndex < numSingleUnparks; ++unparkIndex) { + std::this_thread::sleep_for(std::chrono::microseconds(delay)); + for (unsigned latchIndex = numLatches; latchIndex--;) + tests[latchIndex].unparkOne(unparkIndex); + } + + for (unsigned latchIndex = numLatches; latchIndex--;) + tests[latchIndex].finish(numSingleUnparks); +} + +void repeatParkingTest(unsigned numRepeats, unsigned numLatches, unsigned delay, unsigned numThreads, unsigned numSingleUnparks) +{ + while (numRepeats--) + runParkingTest(numLatches, delay, numThreads, numSingleUnparks); +} + +} // anonymous namespace + +TEST(WTF_ParkingLot, UnparkAllOneFast) +{ + repeatParkingTest(10000, 1, 0, 1, 0); +} + +TEST(WTF_ParkingLot, UnparkAllHundredFast) +{ + repeatParkingTest(100, 1, 0, 100, 0); +} + +TEST(WTF_ParkingLot, UnparkOneOneFast) +{ + repeatParkingTest(1000, 1, 0, 1, 1); +} + +TEST(WTF_ParkingLot, UnparkOneHundredFast) +{ + repeatParkingTest(20, 1, 0, 100, 100); +} + +TEST(WTF_ParkingLot, UnparkOneFiftyThenFiftyAllFast) +{ + repeatParkingTest(50, 1, 0, 100, 50); +} + +TEST(WTF_ParkingLot, UnparkAllOne) +{ + repeatParkingTest(100, 1, 10000, 1, 0); +} + +TEST(WTF_ParkingLot, UnparkAllHundred) +{ + repeatParkingTest(100, 1, 10000, 100, 0); +} + +TEST(WTF_ParkingLot, UnparkOneOne) +{ + repeatParkingTest(10, 1, 10000, 1, 1); +} + +TEST(WTF_ParkingLot, UnparkOneFifty) +{ + repeatParkingTest(1, 1, 10000, 50, 50); +} + +TEST(WTF_ParkingLot, UnparkOneFiftyThenFiftyAll) +{ + repeatParkingTest(2, 1, 10000, 100, 50); +} + +TEST(WTF_ParkingLot, HundredUnparkAllOneFast) +{ + repeatParkingTest(100, 100, 0, 1, 0); +} + +TEST(WTF_ParkingLot, HundredUnparkAllOne) +{ + repeatParkingTest(1, 100, 10000, 1, 0); +} + +} // namespace TestWebKitAPI + diff --git a/Tools/TestWebKitAPI/Tests/WTF/RedBlackTree.cpp b/Tools/TestWebKitAPI/Tests/WTF/RedBlackTree.cpp index 1a1c9fdfc..5e5c8adc4 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/RedBlackTree.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/RedBlackTree.cpp @@ -10,7 +10,7 @@ * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. - * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of + * 3. Neither the name of Apple Inc. ("Apple") nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * diff --git a/Tools/TestWebKitAPI/Tests/WTF/Ref.cpp b/Tools/TestWebKitAPI/Tests/WTF/Ref.cpp index 1b9eef67a..c35606e23 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/Ref.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/Ref.cpp @@ -26,7 +26,6 @@ #include "config.h" #include "RefLogger.h" -#include <wtf/PassRef.h> #include <wtf/Ref.h> #include <wtf/RefPtr.h> @@ -38,14 +37,14 @@ TEST(WTF_Ref, Basic) { Ref<RefLogger> ptr(a); - ASSERT_EQ(&a, &ptr.get()); + ASSERT_EQ(&a, ptr.ptr()); ASSERT_EQ(&a.name, &ptr->name); } ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); { Ref<RefLogger> ptr(adoptRef(a)); - ASSERT_EQ(&a, &ptr.get()); + ASSERT_EQ(&a, ptr.ptr()); ASSERT_EQ(&a.name, &ptr->name); } ASSERT_STREQ("deref(a) ", takeLogStr().c_str()); @@ -59,51 +58,51 @@ TEST(WTF_Ref, Assignment) { Ref<RefLogger> ptr(a); - ASSERT_EQ(&a, &ptr.get()); + ASSERT_EQ(&a, ptr.ptr()); log() << "| "; ptr = b; - ASSERT_EQ(&b, &ptr.get()); + ASSERT_EQ(&b, ptr.ptr()); log() << "| "; } ASSERT_STREQ("ref(a) | ref(b) deref(a) | deref(b) ", takeLogStr().c_str()); { Ref<RefLogger> ptr(a); - ASSERT_EQ(&a, &ptr.get()); + ASSERT_EQ(&a, ptr.ptr()); log() << "| "; ptr = c; - ASSERT_EQ(&c, &ptr.get()); + ASSERT_EQ(&c, ptr.ptr()); log() << "| "; } ASSERT_STREQ("ref(a) | ref(c) deref(a) | deref(c) ", takeLogStr().c_str()); { Ref<RefLogger> ptr(a); - ASSERT_EQ(&a, &ptr.get()); + ASSERT_EQ(&a, ptr.ptr()); log() << "| "; ptr = adoptRef(b); - ASSERT_EQ(&b, &ptr.get()); + ASSERT_EQ(&b, ptr.ptr()); log() << "| "; } ASSERT_STREQ("ref(a) | deref(a) | deref(b) ", takeLogStr().c_str()); { Ref<RefLogger> ptr(a); - ASSERT_EQ(&a, &ptr.get()); + ASSERT_EQ(&a, ptr.ptr()); log() << "| "; ptr = adoptRef(c); - ASSERT_EQ(&c, &ptr.get()); + ASSERT_EQ(&c, ptr.ptr()); log() << "| "; } ASSERT_STREQ("ref(a) | deref(a) | deref(c) ", takeLogStr().c_str()); } -PassRef<RefLogger> passWithPassRef(PassRef<RefLogger> reference) +static Ref<RefLogger> passWithRef(Ref<RefLogger>&& reference) { - return reference; + return WTFMove(reference); } -RefPtr<RefLogger> passWithPassRefPtr(PassRefPtr<RefLogger> reference) +static RefPtr<RefLogger> passWithPassRefPtr(PassRefPtr<RefLogger> reference) { return reference; } @@ -115,32 +114,48 @@ TEST(WTF_Ref, ReturnValue) DerivedRefLogger c("c"); { - Ref<RefLogger> ptr(passWithPassRef(a)); - ASSERT_EQ(&a, &ptr.get()); + Ref<RefLogger> ptr(passWithRef(Ref<RefLogger>(a))); + ASSERT_EQ(&a, ptr.ptr()); } ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); { Ref<RefLogger> ptr(a); - ASSERT_EQ(&a, &ptr.get()); + ASSERT_EQ(&a, ptr.ptr()); log() << "| "; - ptr = passWithPassRef(b); - ASSERT_EQ(&b, &ptr.get()); + ptr = passWithRef(b); + ASSERT_EQ(&b, ptr.ptr()); log() << "| "; } ASSERT_STREQ("ref(a) | ref(b) deref(a) | deref(b) ", takeLogStr().c_str()); { - RefPtr<RefLogger> ptr(passWithPassRef(a)); + RefPtr<RefLogger> ptr(passWithRef(a)); ASSERT_EQ(&a, ptr.get()); } ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); { - RefPtr<RefLogger> ptr(passWithPassRefPtr(passWithPassRef(a))); + RefPtr<RefLogger> ptr(passWithPassRefPtr(passWithRef(a))); ASSERT_EQ(&a, ptr.get()); } ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + RefPtr<DerivedRefLogger> ptr(&a); + RefPtr<RefLogger> ptr2(WTFMove(ptr)); + ASSERT_EQ(nullptr, ptr.get()); + ASSERT_EQ(&a, ptr2.get()); + } + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); + + { + Ref<DerivedRefLogger> derivedReference(a); + Ref<RefLogger> baseReference(passWithRef(derivedReference.copyRef())); + ASSERT_EQ(&a, derivedReference.ptr()); + ASSERT_EQ(&a, baseReference.ptr()); + } + ASSERT_STREQ("ref(a) ref(a) deref(a) deref(a) ", takeLogStr().c_str()); } } // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/RefCounter.cpp b/Tools/TestWebKitAPI/Tests/WTF/RefCounter.cpp new file mode 100644 index 000000000..4c0a14b47 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/RefCounter.cpp @@ -0,0 +1,170 @@ +/* + * Copyright (C) 2011 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <wtf/Ref.h> +#include <wtf/RefCounter.h> +#include <wtf/text/WTFString.h> + +namespace TestWebKitAPI { + +static const int IncrementExpected = 0xC0FFEE1; +static const int DecrementExpected = 0xC0FFEE2; +static const int CallbackNotExpected = 0xDECAF; + +enum TestCounterType { }; +typedef RefCounter<TestCounterType> TestCounter; +typedef TestCounter::Token TokenType; + +TEST(WTF, RefCounter) +{ + // RefCounter API is pretty simple, containing the following 4 methods to test: + // + // 1) RefCounter(std::function<void()>); + // 2) ~RefCounter(); + // 3) Ref<Count> token() const; + // 4) unsigned value() const; + // + // We'll test: + // 1) Construction: + // 1a) with a callback + // 1b) without a callback + // 2) Destruction where the RefCounter::Count has: + // 2a) a non-zero reference count (Count outlives RefCounter). + // 2b) a zero reference count (Count is deleted by RefCounter's destructor). + // 3) Call count to ref/deref the Count object, where: + // 3a) ref with callback from 0 -> 1. + // 3b) ref with callback from 1 -> >1. + // 3c) deref with callback from >1 -> 1. + // 3d) deref with callback from 1 -> 0. + // 3d) deref with callback from 1 -> 0. + // 3e) ref with callback from 1 -> >1 AFTER RefCounter has been destroyed. + // 3f) deref with callback from >1 -> 1 AFTER RefCounter has been destroyed. + // 3g) deref with callback from 1 -> 0 AFTER RefCounter has been destroyed. + // 3h) ref without callback + // 3i) deref without callback + // 3j) ref using a Ref rather than a RefPtr (make sure there is no unnecessary reference count churn). + // 3k) deref using a Ref rather than a RefPtr (make sure there is no unnecessary reference count churn). + // 4) Test the value of the counter: + // 4a) at construction. + // 4b) as read within the callback. + // 4c) as read after the ref/deref. + + // These values will outlive the following block. + int callbackValue = CallbackNotExpected; + TokenType incTo1Again; + + { + // Testing (1a) - Construction with a callback. + TestCounter* counterPtr = nullptr; + TestCounter counter([&](RefCounterEvent event) { + // Check that the callback is called at the expected times, and the correct number of times. + if (RefCounterEvent::Increment == event) + EXPECT_EQ(callbackValue, IncrementExpected); + if (RefCounterEvent::Decrement == event) + EXPECT_EQ(callbackValue, DecrementExpected); + // return the value of the counter in the callback. + callbackValue = counterPtr->value(); + }); + counterPtr = &counter; + // Testing (4a) - after construction value() is 0. + EXPECT_EQ(0, static_cast<int>(counter.value())); + + // Testing (3a) - ref with callback from 0 -> 1. + callbackValue = IncrementExpected; + TokenType incTo1(counter.count()); + // Testing (4b) & (4c) - values within & after callback. + EXPECT_EQ(1, callbackValue); + EXPECT_EQ(1, static_cast<int>(counter.value())); + + // Testing (3b) - ref with callback from 1 -> 2. + callbackValue = IncrementExpected; + TokenType incTo2(incTo1); + // Testing (4b) & (4c) - values within & after callback. + EXPECT_EQ(2, callbackValue); + EXPECT_EQ(2, static_cast<int>(counter.value())); + + // Testing (3c) - deref with callback from >1 -> 1. + callbackValue = DecrementExpected; + incTo1 = nullptr; + // Testing (4b) & (4c) - values within & after callback. + EXPECT_EQ(1, callbackValue); + EXPECT_EQ(1, static_cast<int>(counter.value())); + + { + // Testing (3j) - ref using a Ref rather than a RefPtr. + callbackValue = IncrementExpected; + TokenType incTo2Again(counter.count()); + // Testing (4b) & (4c) - values within & after callback. + EXPECT_EQ(2, callbackValue); + EXPECT_EQ(2, static_cast<int>(counter.value())); + // Testing (3k) - deref using a Ref rather than a RefPtr. + + callbackValue = DecrementExpected; + } + EXPECT_EQ(1, callbackValue); + EXPECT_EQ(1, static_cast<int>(counter.value())); + // Testing (4b) & (4c) - values within & after callback. + + // Testing (3d) - deref with callback from 1 -> 0. + callbackValue = DecrementExpected; + incTo2 = nullptr; + // Testing (4b) & (4c) - values within & after callback. + EXPECT_EQ(0, callbackValue); + EXPECT_EQ(0, static_cast<int>(counter.value())); + + // Testing (2a) - Destruction where the TestCounter::Count has a non-zero reference count. + callbackValue = IncrementExpected; + incTo1Again = counter.count(); + EXPECT_EQ(1, callbackValue); + EXPECT_EQ(1, static_cast<int>(counter.value())); + callbackValue = CallbackNotExpected; + } + + // Testing (3e) - ref with callback from 1 -> >1 AFTER RefCounter has been destroyed. + TokenType incTo2Again = incTo1Again; + // Testing (3f) - deref with callback from >1 -> 1 AFTER RefCounter has been destroyed. + incTo1Again = nullptr; + // Testing (3g) - deref with callback from 1 -> 0 AFTER RefCounter has been destroyed. + incTo2Again = nullptr; + + // Testing (1b) - Construction without a callback. + TestCounter counter; + // Testing (4a) - after construction value() is 0. + EXPECT_EQ(0, static_cast<int>(counter.value())); + // Testing (3h) - ref without callback + TokenType incTo1(counter.count()); + // Testing (4c) - value as read after the ref. + EXPECT_EQ(1, static_cast<int>(counter.value())); + // Testing (3i) - deref without callback + incTo1 = nullptr; + // Testing (4c) - value as read after the deref. + EXPECT_EQ(0, static_cast<int>(counter.value())); + // Testing (2b) - Destruction where the RefCounter::Count has a zero reference count. + // ... not a lot to test here! - we can at least ensure this code path is run & we don't crash! +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/RefLogger.cpp b/Tools/TestWebKitAPI/Tests/WTF/RefLogger.cpp new file mode 100644 index 000000000..f468a312c --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/RefLogger.cpp @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2013, 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "RefLogger.h" + +namespace TestWebKitAPI { + +std::ostringstream& log() +{ + static std::ostringstream log; + return log; +} + +} diff --git a/Tools/TestWebKitAPI/Tests/WTF/RefLogger.h b/Tools/TestWebKitAPI/Tests/WTF/RefLogger.h index 2bb5c36fa..02547dfec 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/RefLogger.h +++ b/Tools/TestWebKitAPI/Tests/WTF/RefLogger.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2013 Apple Inc. All rights reserved. + * Copyright (C) 2013, 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 @@ -27,11 +27,7 @@ namespace TestWebKitAPI { -inline std::ostringstream& log() -{ - static std::ostringstream log; - return log; -} +std::ostringstream& log(); inline std::string takeLogStr() { @@ -48,7 +44,7 @@ struct RefLogger { }; struct DerivedRefLogger : RefLogger { - DerivedRefLogger(const char* name) : RefLogger(name) { } + DerivedRefLogger(const char* name) : RefLogger(name) { log().str(""); } }; } diff --git a/Tools/TestWebKitAPI/Tests/WTF/RefPtr.cpp b/Tools/TestWebKitAPI/Tests/WTF/RefPtr.cpp index bc1e1e484..172efa762 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/RefPtr.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/RefPtr.cpp @@ -26,6 +26,8 @@ #include "config.h" #include "RefLogger.h" +#include <wtf/NeverDestroyed.h> +#include <wtf/RefCounted.h> #include <wtf/RefPtr.h> namespace TestWebKitAPI { @@ -69,7 +71,7 @@ TEST(WTF_RefPtr, Basic) { RefPtr<RefLogger> p1 = &a; - RefPtr<RefLogger> p2 = std::move(p1); + RefPtr<RefLogger> p2 = WTFMove(p1); ASSERT_EQ(nullptr, p1.get()); ASSERT_EQ(&a, p2.get()); } @@ -77,7 +79,7 @@ TEST(WTF_RefPtr, Basic) { RefPtr<RefLogger> p1 = &a; - RefPtr<RefLogger> p2(std::move(p1)); + RefPtr<RefLogger> p2(WTFMove(p1)); ASSERT_EQ(nullptr, p1.get()); ASSERT_EQ(&a, p2.get()); } @@ -93,7 +95,7 @@ TEST(WTF_RefPtr, Basic) { RefPtr<DerivedRefLogger> p1 = &a; - RefPtr<RefLogger> p2 = std::move(p1); + RefPtr<RefLogger> p2 = WTFMove(p1); ASSERT_EQ(nullptr, p1.get()); ASSERT_EQ(&a, p2.get()); } @@ -102,7 +104,7 @@ TEST(WTF_RefPtr, Basic) { RefPtr<RefLogger> ptr(&a); ASSERT_EQ(&a, ptr.get()); - ptr.clear(); + ptr = nullptr; ASSERT_EQ(nullptr, ptr.get()); } ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); @@ -120,8 +122,8 @@ TEST(WTF_RefPtr, AssignPassRefToRefPtr) { DerivedRefLogger a("a"); { - PassRef<RefLogger> passRef(a); - RefPtr<RefLogger> ptr = std::move(passRef); + Ref<RefLogger> passRef(a); + RefPtr<RefLogger> ptr = WTFMove(passRef); ASSERT_EQ(&a, ptr.get()); ptr.release(); ASSERT_EQ(nullptr, ptr.get()); @@ -204,7 +206,7 @@ TEST(WTF_RefPtr, Assignment) ASSERT_EQ(&a, p1.get()); ASSERT_EQ(&b, p2.get()); log() << "| "; - p1 = std::move(p2); + p1 = WTFMove(p2); ASSERT_EQ(&b, p1.get()); ASSERT_EQ(nullptr, p2.get()); log() << "| "; @@ -250,7 +252,7 @@ TEST(WTF_RefPtr, Assignment) ASSERT_EQ(&a, p1.get()); ASSERT_EQ(&c, p2.get()); log() << "| "; - p1 = std::move(p2); + p1 = WTFMove(p2); ASSERT_EQ(&c, p1.get()); ASSERT_EQ(nullptr, p2.get()); log() << "| "; @@ -270,7 +272,15 @@ TEST(WTF_RefPtr, Assignment) { RefPtr<RefLogger> ptr(&a); ASSERT_EQ(&a, ptr.get()); - ptr = std::move(ptr); +#if COMPILER(CLANG) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunknown-pragmas" +#pragma clang diagnostic ignored "-Wself-move" +#endif + ptr = WTFMove(ptr); +#if COMPILER(CLANG) +#pragma clang diagnostic pop +#endif ASSERT_EQ(&a, ptr.get()); } ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); @@ -395,4 +405,34 @@ TEST(WTF_RefPtr, ReturnValue) ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); } + +struct ConstRefCounted : RefCounted<ConstRefCounted> { + static Ref<ConstRefCounted> create() { return adoptRef(*new ConstRefCounted); } +}; + +const ConstRefCounted& returnConstRefCountedRef() +{ + static NeverDestroyed<ConstRefCounted> instance; + return instance.get(); +} +ConstRefCounted& returnRefCountedRef() +{ + static NeverDestroyed<ConstRefCounted> instance; + return instance.get(); +} + +TEST(WTF_RefPtr, Const) +{ + // This test passes if it compiles without an error. + auto a = ConstRefCounted::create(); + Ref<const ConstRefCounted> b = WTFMove(a); + RefPtr<const ConstRefCounted> c = b.ptr(); + Ref<const ConstRefCounted> d = returnConstRefCountedRef(); + RefPtr<const ConstRefCounted> e = &returnConstRefCountedRef(); + RefPtr<ConstRefCounted> f = ConstRefCounted::create(); + RefPtr<const ConstRefCounted> g = f; + RefPtr<const ConstRefCounted> h(f); + Ref<const ConstRefCounted> i(returnRefCountedRef()); +} + } // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/RunLoop.cpp b/Tools/TestWebKitAPI/Tests/WTF/RunLoop.cpp new file mode 100644 index 000000000..1dc7e938a --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/RunLoop.cpp @@ -0,0 +1,166 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "Utilities.h" +#include <wtf/RunLoop.h> + +namespace TestWebKitAPI { + +static bool testFinished; +static int count = 100; + +TEST(WTF_RunLoop, Deadlock) +{ + RunLoop::initializeMainRunLoop(); + + struct DispatchFromDestructorTester { + ~DispatchFromDestructorTester() { + RunLoop::main().dispatch([] { + if (!(--count)) + testFinished = true; + }); + } + }; + + for (int i = 0; i < count; ++i) { + auto capture = std::make_shared<DispatchFromDestructorTester>(); + RunLoop::main().dispatch([capture] { }); + } + + Util::run(&testFinished); +} + +TEST(WTF_RunLoop, NestedRunLoop) +{ + RunLoop::initializeMainRunLoop(); + + bool testFinished = false; + RunLoop::current().dispatch([&] { + RunLoop::current().dispatch([&] { + testFinished = true; + }); + Util::run(&testFinished); + }); + + Util::run(&testFinished); +} + +TEST(WTF_RunLoop, OneShotTimer) +{ + RunLoop::initializeMainRunLoop(); + + bool testFinished = false; + + class DerivedTimer : public RunLoop::Timer<DerivedTimer> { + public: + DerivedTimer(bool& testFinished) + : RunLoop::Timer<DerivedTimer>(RunLoop::current(), this, &DerivedTimer::fired) + , m_testFinished(testFinished) + { + } + + void fired() + { + m_testFinished = true; + stop(); + } + + private: + bool& m_testFinished; + }; + + { + DerivedTimer timer(testFinished); + timer.startOneShot(0.1); + Util::run(&testFinished); + } +} + +TEST(WTF_RunLoop, RepeatingTimer) +{ + RunLoop::initializeMainRunLoop(); + + bool testFinished = false; + + class DerivedTimer : public RunLoop::Timer<DerivedTimer> { + public: + DerivedTimer(bool& testFinished) + : RunLoop::Timer<DerivedTimer>(RunLoop::current(), this, &DerivedTimer::fired) + , m_testFinished(testFinished) + { + } + + void fired() + { + if (++m_count == 10) { + m_testFinished = true; + stop(); + } + } + + private: + unsigned m_count { 0 }; + bool& m_testFinished; + }; + + { + DerivedTimer timer(testFinished); + timer.startRepeating(0.01); + Util::run(&testFinished); + } +} + +TEST(WTF_RunLoop, ManyTimes) +{ + RunLoop::initializeMainRunLoop(); + + class Counter { + public: + void run() + { + if (++m_count == 100000) { + RunLoop::current().stop(); + return; + } + RunLoop::current().dispatch([this] { + run(); + }); + } + + private: + unsigned m_count { 0 }; + }; + + Counter counter; + + RunLoop::current().dispatch([&counter] { + counter.run(); + }); + RunLoop::run(); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/Scope.cpp b/Tools/TestWebKitAPI/Tests/WTF/Scope.cpp new file mode 100644 index 000000000..08f5ce327 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/Scope.cpp @@ -0,0 +1,53 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include <wtf/Scope.h> + +namespace TestWebKitAPI { + +TEST(WTF_Scope, ScopeExit) +{ + bool isCalled = false; + { + auto scopeExit = makeScopeExit([&] { + EXPECT_FALSE(isCalled); + isCalled = true; + }); + EXPECT_FALSE(isCalled); + } + EXPECT_TRUE(isCalled); + + isCalled = false; + { + auto scopeExit = makeScopeExit([&] { + isCalled = true; + }); + scopeExit.release(); + } + EXPECT_FALSE(isCalled); +} + +} diff --git a/Tools/TestWebKitAPI/Tests/WTF/ScopedLambda.cpp b/Tools/TestWebKitAPI/Tests/WTF/ScopedLambda.cpp new file mode 100644 index 000000000..3dfee8671 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/ScopedLambda.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include <wtf/ScopedLambda.h> +#include <wtf/Vector.h> + +using namespace WTF; + +namespace TestWebKitAPI { + +// This test relies on this module being compiled with -fno-elide-constructors +TEST(WTF_ScopedLambda, NoRVOLivenessBug) +{ + Vector<int> vector; + for (unsigned i = 0; i < 10; ++i) + vector.append(i); + + auto lambda = scopedLambda<int(size_t)>( + [=] (size_t i) -> int { + return vector[i]; + }); + + for (unsigned i = 0; i < 10; ++i) + EXPECT_EQ(i, static_cast<unsigned>(lambda(i))); +} + +} // namespace TestWebKitAPI + diff --git a/Tools/TestWebKitAPI/Tests/WTF/TemporaryChange.cpp b/Tools/TestWebKitAPI/Tests/WTF/SetForScope.cpp index 3ba0f15bd..92e3494d6 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/TemporaryChange.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/SetForScope.cpp @@ -25,18 +25,18 @@ #include "config.h" -#include <wtf/TemporaryChange.h> +#include <wtf/SetForScope.h> namespace TestWebKitAPI { -TEST(WTF, TemporaryChangeNested) +TEST(WTF, SetForScopeNested) { bool originallyFalse = false; { - TemporaryChange<bool> change1OriginallyFalse(originallyFalse, true); + SetForScope<bool> change1OriginallyFalse(originallyFalse, true); EXPECT_TRUE(originallyFalse); { - TemporaryChange<bool> change2OriginallyFalse(originallyFalse, false); + SetForScope<bool> change2OriginallyFalse(originallyFalse, false); EXPECT_FALSE(originallyFalse); } EXPECT_TRUE(originallyFalse); diff --git a/Tools/TestWebKitAPI/Tests/WTF/StringBuilder.cpp b/Tools/TestWebKitAPI/Tests/WTF/StringBuilder.cpp index 9ca5d6ee8..11bf3590e 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/StringBuilder.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/StringBuilder.cpp @@ -38,14 +38,17 @@ static void expectBuilderContent(const String& expected, const StringBuilder& bu { // Not using builder.toString() or builder.toStringPreserveCapacity() because they all // change internal state of builder. - EXPECT_EQ(expected, String(builder.deprecatedCharacters(), builder.length())); + if (builder.is8Bit()) + EXPECT_EQ(expected, String(builder.characters8(), builder.length())); + else + EXPECT_EQ(expected, String(builder.characters16(), builder.length())); } void expectEmpty(const StringBuilder& builder) { EXPECT_EQ(0U, builder.length()); EXPECT_TRUE(builder.isEmpty()); - EXPECT_EQ(0, builder.deprecatedCharacters()); + EXPECT_EQ(0, builder.characters8()); } TEST(StringBuilderTest, DefaultConstructor) @@ -72,20 +75,20 @@ TEST(StringBuilderTest, Append) StringBuilder builder1; builder.append("", 0); expectBuilderContent("0123456789abcdefg#", builder); - builder1.append(builder.deprecatedCharacters(), builder.length()); + builder1.append(builder.characters8(), builder.length()); builder1.append("XYZ"); - builder.append(builder1.deprecatedCharacters(), builder1.length()); + builder.append(builder1.characters8(), builder1.length()); expectBuilderContent("0123456789abcdefg#0123456789abcdefg#XYZ", builder); StringBuilder builder2; builder2.reserveCapacity(100); builder2.append("xyz"); - const UChar* characters = builder2.deprecatedCharacters(); + const LChar* characters = builder2.characters8(); builder2.append("0123456789"); - ASSERT_EQ(characters, builder2.deprecatedCharacters()); + ASSERT_EQ(characters, builder2.characters8()); builder2.toStringPreserveCapacity(); // Test after reifyString with buffer preserved. builder2.append("abcd"); - ASSERT_EQ(characters, builder2.deprecatedCharacters()); + ASSERT_EQ(characters, builder2.characters8()); // Test appending UChar32 characters to StringBuilder. StringBuilder builderForUChar32Append; @@ -140,7 +143,7 @@ TEST(StringBuilderTest, ToStringPreserveCapacity) ASSERT_EQ(capacity, builder.capacity()); ASSERT_EQ(String("0123456789"), string); ASSERT_EQ(string.impl(), builder.toStringPreserveCapacity().impl()); - ASSERT_EQ(string.deprecatedCharacters(), builder.deprecatedCharacters()); + ASSERT_EQ(string.characters8(), builder.characters8()); // Changing the StringBuilder should not affect the original result of toStringPreserveCapacity(). builder.append("abcdefghijklmnopqrstuvwxyz"); @@ -151,7 +154,7 @@ TEST(StringBuilderTest, ToStringPreserveCapacity) capacity = builder.capacity(); string = builder.toStringPreserveCapacity(); ASSERT_EQ(capacity, builder.capacity()); - ASSERT_EQ(string.deprecatedCharacters(), builder.deprecatedCharacters()); + ASSERT_EQ(string.characters8(), builder.characters8()); ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyz"), string); builder.append("ABC"); ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyz"), string); @@ -160,7 +163,7 @@ TEST(StringBuilderTest, ToStringPreserveCapacity) capacity = builder.capacity(); String string1 = builder.toStringPreserveCapacity(); ASSERT_EQ(capacity, builder.capacity()); - ASSERT_EQ(string1.deprecatedCharacters(), builder.deprecatedCharacters()); + ASSERT_EQ(string1.characters8(), builder.characters8()); ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), string1); string1.append("DEF"); ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), builder.toStringPreserveCapacity()); @@ -170,7 +173,7 @@ TEST(StringBuilderTest, ToStringPreserveCapacity) capacity = builder.capacity(); string1 = builder.toStringPreserveCapacity(); ASSERT_EQ(capacity, builder.capacity()); - ASSERT_EQ(string.deprecatedCharacters(), builder.deprecatedCharacters()); + ASSERT_EQ(string.characters8(), builder.characters8()); builder.resize(10); builder.append("###"); ASSERT_EQ(String("0123456789abcdefghijklmnopqrstuvwxyzABC"), string1); diff --git a/Tools/TestWebKitAPI/Tests/WTF/StringConcatenate.cpp b/Tools/TestWebKitAPI/Tests/WTF/StringConcatenate.cpp new file mode 100644 index 000000000..fc25b08f8 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/StringConcatenate.cpp @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2017 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "WTFStringUtilities.h" +#include <wtf/text/StringConcatenate.h> +#include <wtf/text/StringConcatenateNumbers.h> + +namespace TestWebKitAPI { + +TEST(WTF, StringConcatenate) +{ + EXPECT_EQ("hello world", makeString("hello", " ", "world")); +} + +TEST(WTF, StringConcatenate_Int) +{ + EXPECT_EQ(5u, WTF::lengthOfNumberAsStringSigned(17890)); + EXPECT_EQ("hello 17890 world", makeString("hello ", 17890 , " world")); + + EXPECT_EQ(6u, WTF::lengthOfNumberAsStringSigned(-17890)); + EXPECT_EQ("hello -17890 world", makeString("hello ", -17890 , " world")); + + EXPECT_EQ(1u, WTF::lengthOfNumberAsStringSigned(0)); + EXPECT_EQ("hello 0 world", makeString("hello ", 0 , " world")); +} + +TEST(WTF, StringConcatenate_Unsigned) +{ + EXPECT_EQ(5u, WTF::lengthOfNumberAsStringUnsigned(17890u)); + EXPECT_EQ("hello 17890 world", makeString("hello ", 17890u , " world")); + + EXPECT_EQ(1u, WTF::lengthOfNumberAsStringSigned(0u)); + EXPECT_EQ("hello 0 world", makeString("hello ", 0u , " world")); +} + +TEST(WTF, StringConcatenate_Float) +{ + EXPECT_EQ("hello 17890 world", makeString("hello ", 17890.0f , " world")); + EXPECT_EQ("hello 17890.5 world", makeString("hello ", 17890.5f , " world")); + + EXPECT_EQ("hello -17890 world", makeString("hello ", -17890.0f , " world")); + EXPECT_EQ("hello -17890.5 world", makeString("hello ", -17890.5f , " world")); + + EXPECT_EQ("hello 0 world", makeString("hello ", 0.0f , " world")); +} + +TEST(WTF, StringConcatenate_Double) +{ + EXPECT_EQ("hello 17890 world", makeString("hello ", 17890.0 , " world")); + EXPECT_EQ("hello 17890.5 world", makeString("hello ", 17890.5 , " world")); + + EXPECT_EQ("hello -17890 world", makeString("hello ", -17890.0 , " world")); + EXPECT_EQ("hello -17890.5 world", makeString("hello ", -17890.5 , " world")); + + EXPECT_EQ("hello 0 world", makeString("hello ", 0.0 , " world")); +} + +TEST(WTF, StringConcatenate_FormattedDoubleFixedPrecision) +{ + EXPECT_EQ("hello 17890.0 world", makeString("hello ", FormattedNumber::fixedPrecision(17890.0) , " world")); + EXPECT_EQ("hello 1.79e+4 world", makeString("hello ", FormattedNumber::fixedPrecision(17890.0, 3) , " world")); + EXPECT_EQ("hello 17890.000 world", makeString("hello ", FormattedNumber::fixedPrecision(17890.0, 8) , " world")); + EXPECT_EQ("hello 17890 world", makeString("hello ", FormattedNumber::fixedPrecision(17890.0, 8, true) , " world")); + + EXPECT_EQ("hello 17890.5 world", makeString("hello ", FormattedNumber::fixedPrecision(17890.5) , " world")); + EXPECT_EQ("hello 1.79e+4 world", makeString("hello ", FormattedNumber::fixedPrecision(17890.5, 3) , " world")); + EXPECT_EQ("hello 17890.500 world", makeString("hello ", FormattedNumber::fixedPrecision(17890.5, 8) , " world")); + EXPECT_EQ("hello 17890.5 world", makeString("hello ", FormattedNumber::fixedPrecision(17890.5, 8, true) , " world")); + + EXPECT_EQ("hello -17890.0 world", makeString("hello ", FormattedNumber::fixedPrecision(-17890.0) , " world")); + EXPECT_EQ("hello -1.79e+4 world", makeString("hello ", FormattedNumber::fixedPrecision(-17890.0, 3) , " world")); + EXPECT_EQ("hello -17890.000 world", makeString("hello ", FormattedNumber::fixedPrecision(-17890.0, 8) , " world")); + EXPECT_EQ("hello -17890 world", makeString("hello ", FormattedNumber::fixedPrecision(-17890.0, 8, true) , " world")); + + EXPECT_EQ("hello -17890.5 world", makeString("hello ", FormattedNumber::fixedPrecision(-17890.5) , " world")); + EXPECT_EQ("hello -1.79e+4 world", makeString("hello ", FormattedNumber::fixedPrecision(-17890.5, 3) , " world")); + EXPECT_EQ("hello -17890.500 world", makeString("hello ", FormattedNumber::fixedPrecision(-17890.5, 8) , " world")); + EXPECT_EQ("hello -17890.5 world", makeString("hello ", FormattedNumber::fixedPrecision(-17890.5, 8, true) , " world")); + + EXPECT_EQ("hello 0.00000 world", makeString("hello ", FormattedNumber::fixedPrecision(0.0) , " world")); + EXPECT_EQ("hello 0.00 world", makeString("hello ", FormattedNumber::fixedPrecision(0.0, 3) , " world")); + EXPECT_EQ("hello 0.0000000 world", makeString("hello ", FormattedNumber::fixedPrecision(0.0, 8) , " world")); + EXPECT_EQ("hello 0 world", makeString("hello ", FormattedNumber::fixedPrecision(0.0, 8, true) , " world")); +} + +TEST(WTF, StringConcatenate_FormattedDoubleFixedWidth) +{ + EXPECT_EQ("hello 17890.000 world", makeString("hello ", FormattedNumber::fixedWidth(17890.0, 3) , " world")); + EXPECT_EQ("hello 17890.500 world", makeString("hello ", FormattedNumber::fixedWidth(17890.5, 3) , " world")); + + EXPECT_EQ("hello -17890.000 world", makeString("hello ", FormattedNumber::fixedWidth(-17890.0, 3) , " world")); + EXPECT_EQ("hello -17890.500 world", makeString("hello ", FormattedNumber::fixedWidth(-17890.5, 3) , " world")); + + EXPECT_EQ("hello 0.000 world", makeString("hello ", FormattedNumber::fixedWidth(0.0, 3) , " world")); +} + +} diff --git a/Tools/TestWebKitAPI/Tests/WTF/StringHasher.cpp b/Tools/TestWebKitAPI/Tests/WTF/StringHasher.cpp index a4d223c99..5985b026a 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/StringHasher.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/StringHasher.cpp @@ -25,7 +25,7 @@ #include "config.h" -#include <wtf/StringHasher.h> +#include <wtf/Hasher.h> namespace TestWebKitAPI { @@ -264,6 +264,43 @@ TEST(WTF, StringHasher_addCharacters) hasher.addCharacters(testBUChars + 3); ASSERT_EQ(testBHash5, hasher.hash()); ASSERT_EQ(testBHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked()); + + // Hashing zero characters after hashing other characters. + hasher = StringHasher(); + hasher.addCharacters(nullLChars, 0); + hasher.addCharacters(nullLChars, 0); + ASSERT_EQ(emptyStringHash, hasher.hash()); + ASSERT_EQ(emptyStringHash & 0xFFFFFF, hasher.hashWithTop8BitsMasked()); + + hasher = StringHasher(); + hasher.addCharacters(testALChars, 1); + hasher.addCharacters(nullLChars, 0); + ASSERT_EQ(testAHash1, hasher.hash()); + ASSERT_EQ(testAHash1 & 0xFFFFFF, hasher.hashWithTop8BitsMasked()); + + hasher = StringHasher(); + hasher.addCharacters(testALChars, 2); + hasher.addCharacters(nullLChars, 0); + ASSERT_EQ(testAHash2, hasher.hash()); + ASSERT_EQ(testAHash2 & 0xFFFFFF, hasher.hashWithTop8BitsMasked()); + + hasher = StringHasher(); + hasher.addCharacters(testAUChars, 3); + hasher.addCharacters(nullLChars, 0); + ASSERT_EQ(testAHash3, hasher.hash()); + ASSERT_EQ(testAHash3 & 0xFFFFFF, hasher.hashWithTop8BitsMasked()); + + hasher = StringHasher(); + hasher.addCharacters(testALChars, 4); + hasher.addCharacters(nullLChars, 0); + ASSERT_EQ(testAHash4, hasher.hash()); + ASSERT_EQ(testAHash4 & 0xFFFFFF, hasher.hashWithTop8BitsMasked()); + + hasher = StringHasher(); + hasher.addCharacters(testALChars, 5); + hasher.addCharacters(nullLChars, 0); + ASSERT_EQ(testAHash5, hasher.hash()); + ASSERT_EQ(testAHash5 & 0xFFFFFF, hasher.hashWithTop8BitsMasked()); } TEST(WTF, StringHasher_addCharactersAssumingAligned) @@ -427,18 +464,18 @@ TEST(WTF, StringHasher_computeHashAndMaskTop8Bits) TEST(WTF, StringHasher_hashMemory) { - ASSERT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::hashMemory(0, 0)); - ASSERT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::hashMemory(nullUChars, 0)); - ASSERT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::hashMemory<0>(0)); - ASSERT_EQ(emptyStringHash & 0xFFFFFF, StringHasher::hashMemory<0>(nullUChars)); - - ASSERT_EQ(singleNullCharacterHash & 0xFFFFFF, StringHasher::hashMemory(nullUChars, 2)); - ASSERT_EQ(singleNullCharacterHash & 0xFFFFFF, StringHasher::hashMemory<2>(nullUChars)); - - ASSERT_EQ(testAHash5 & 0xFFFFFF, StringHasher::hashMemory(testAUChars, 10)); - ASSERT_EQ(testAHash5 & 0xFFFFFF, StringHasher::hashMemory<10>(testAUChars)); - ASSERT_EQ(testBHash5 & 0xFFFFFF, StringHasher::hashMemory(testBUChars, 10)); - ASSERT_EQ(testBHash5 & 0xFFFFFF, StringHasher::hashMemory<10>(testBUChars)); + ASSERT_EQ(emptyStringHash, StringHasher::hashMemory(0, 0)); + ASSERT_EQ(emptyStringHash, StringHasher::hashMemory(nullUChars, 0)); + ASSERT_EQ(emptyStringHash, StringHasher::hashMemory<0>(0)); + ASSERT_EQ(emptyStringHash, StringHasher::hashMemory<0>(nullUChars)); + + ASSERT_EQ(singleNullCharacterHash, StringHasher::hashMemory(nullUChars, 2)); + ASSERT_EQ(singleNullCharacterHash, StringHasher::hashMemory<2>(nullUChars)); + + ASSERT_EQ(testAHash5, StringHasher::hashMemory(testAUChars, 10)); + ASSERT_EQ(testAHash5, StringHasher::hashMemory<10>(testAUChars)); + ASSERT_EQ(testBHash5, StringHasher::hashMemory(testBUChars, 10)); + ASSERT_EQ(testBHash5, StringHasher::hashMemory<10>(testBUChars)); } } // namespace TestWebKitAPI 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 diff --git a/Tools/TestWebKitAPI/Tests/WTF/StringOperators.cpp b/Tools/TestWebKitAPI/Tests/WTF/StringOperators.cpp index 149b85b21..7a1d9297f 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/StringOperators.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/StringOperators.cpp @@ -184,4 +184,20 @@ TEST(WTF, StringOperators) #endif } +TEST(WTF, ConcatenateCharacterArrayAndEmptyString) +{ + String emptyString; + EXPECT_EQ(static_cast<unsigned>(0), emptyString.length()); + + UChar ucharArray[] = { 't', 'e', 's', 't', '\0' }; + String concatenation16 = ucharArray + emptyString; + ASSERT_EQ(static_cast<unsigned>(4), concatenation16.length()); + ASSERT_TRUE(concatenation16 == String(ucharArray)); + + LChar lcharArray[] = { 't', 'e', 's', 't', '\0' }; + String concatenation8 = lcharArray + emptyString; + ASSERT_EQ(static_cast<unsigned>(4), concatenation8.length()); + ASSERT_TRUE(concatenation8 == String(lcharArray)); +} + } // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/StringView.cpp b/Tools/TestWebKitAPI/Tests/WTF/StringView.cpp new file mode 100644 index 000000000..93592834a --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/StringView.cpp @@ -0,0 +1,928 @@ +/* + * Copyright (C) 2014 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <wtf/text/StringBuilder.h> +#include <wtf/text/StringView.h> + +namespace TestWebKitAPI { + +StringView stringViewFromLiteral(const char* characters) +{ + return StringView(reinterpret_cast<const LChar*>(characters), strlen(characters)); +} + +StringView stringViewFromUTF8(String &ref, const char* characters) +{ + ref = String::fromUTF8(characters); + return ref; +} + +TEST(WTF, StringViewEmptyVsNull) +{ + StringView nullView; + EXPECT_TRUE(nullView.isNull()); + EXPECT_TRUE(nullView.isEmpty()); + + // Test in a boolean context to test operator bool(). + if (nullView) + FAIL(); + else + SUCCEED(); + + if (!nullView) + SUCCEED(); + else + FAIL(); + + StringView emptyView = StringView::empty(); + EXPECT_FALSE(emptyView.isNull()); + EXPECT_TRUE(emptyView.isEmpty()); + + // Test in a boolean context to test operator bool(). + if (emptyView) + SUCCEED(); + else + FAIL(); + + if (!emptyView) + FAIL(); + else + SUCCEED(); + + StringView viewWithCharacters(String("hello")); + EXPECT_FALSE(viewWithCharacters.isNull()); + EXPECT_FALSE(viewWithCharacters.isEmpty()); + + // Test in a boolean context to test operator bool(). + if (viewWithCharacters) + SUCCEED(); + else + FAIL(); + + if (!viewWithCharacters) + FAIL(); + else + SUCCEED(); +} + +bool compareLoopIterations(StringView::GraphemeClusters graphemeClusters, std::vector<StringView> expected) +{ + std::vector<StringView> actual; + for (auto graphemeCluster : graphemeClusters) + actual.push_back(graphemeCluster); + return actual == expected; +} + +bool compareLoopIterations(StringView::CodePoints codePoints, std::vector<UChar32> expected) +{ + std::vector<UChar32> actual; + for (auto codePoint : codePoints) + actual.push_back(codePoint); + return actual == expected; +} + +static bool compareLoopIterations(StringView::CodeUnits codeUnits, std::vector<UChar> expected) +{ + std::vector<UChar> actual; + for (auto codeUnit : codeUnits) + actual.push_back(codeUnit); + return actual == expected; +} + +static void build(StringBuilder& builder, std::vector<UChar> input) +{ + builder.clear(); + for (auto codeUnit : input) + builder.append(codeUnit); +} + +TEST(WTF, StringViewIterators) +{ + EXPECT_TRUE(compareLoopIterations(StringView().codePoints(), { })); + EXPECT_TRUE(compareLoopIterations(StringView().codeUnits(), { })); + EXPECT_TRUE(compareLoopIterations(StringView().graphemeClusters(), { })); + + EXPECT_TRUE(compareLoopIterations(StringView::empty().codePoints(), { })); + EXPECT_TRUE(compareLoopIterations(StringView::empty().codeUnits(), { })); + EXPECT_TRUE(compareLoopIterations(StringView::empty().graphemeClusters(), { })); + + String helo("helo"); + StringView heloView(helo); + + auto codePoints = heloView.codePoints(); + auto codePointsIterator = codePoints.begin(); + EXPECT_EQ(*codePointsIterator, 'h'); + EXPECT_EQ(*codePointsIterator, 'h'); + ++codePointsIterator; + ++codePointsIterator; + EXPECT_EQ(*codePointsIterator, 'l'); + auto savedIterator = codePointsIterator; + codePointsIterator = codePoints.begin(); + EXPECT_EQ(*codePointsIterator, 'h'); + codePointsIterator = savedIterator; + EXPECT_EQ(*codePointsIterator, 'l'); + String webkit("webkit"); + auto webkitCodePoints = StringView(webkit).codePoints(); + codePointsIterator = webkitCodePoints.begin(); + ++codePointsIterator; + ++codePointsIterator; + EXPECT_EQ(*codePointsIterator, 'b'); + while (codePointsIterator != webkitCodePoints.end()) + ++codePointsIterator; + + EXPECT_TRUE(compareLoopIterations(heloView.codePoints(), {'h', 'e', 'l', 'o'})); + EXPECT_TRUE(compareLoopIterations(heloView.codeUnits(), {'h', 'e', 'l', 'o'})); + EXPECT_TRUE(compareLoopIterations(heloView.graphemeClusters(), { + StringView(heloView.characters8(), 1), + StringView(heloView.characters8() + 1, 1), + StringView(heloView.characters8() + 2, 1), + StringView(heloView.characters8() + 3, 1)})); + + StringBuilder b; + build(b, {0xD800, 0xDD55}); // Surrogates for unicode code point U+10155 + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codePoints(), {0x10155})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codeUnits(), {0xD800, 0xDD55})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).graphemeClusters(), {StringView(b.toString())})); + + build(b, {0xD800}); // Leading surrogate only + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codePoints(), {0xD800})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codeUnits(), {0xD800})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).graphemeClusters(), {StringView(b.toString())})); + + build(b, {0xD800, 0xD801}); // Two leading surrogates + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codePoints(), {0xD800, 0xD801})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codeUnits(), {0xD800, 0xD801})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).graphemeClusters(), {StringView(b.characters16(), 1), StringView(b.characters16() + 1, 1)})); + + build(b, {0xDD55}); // Trailing surrogate only + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codePoints(), {0xDD55})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codeUnits(), {0xDD55})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).graphemeClusters(), {StringView(b.toString())})); + + build(b, {0xD800, 'h'}); // Leading surrogate followed by non-surrogate + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codePoints(), {0xD800, 'h'})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codeUnits(), {0xD800, 'h'})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).graphemeClusters(), {StringView(b.characters16(), 1), StringView(b.characters16() + 1, 1)})); + + build(b, {0x0306}); // "COMBINING BREVE" + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codePoints(), {0x0306})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codeUnits(), {0x0306})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).graphemeClusters(), {StringView(b.toString())})); + + build(b, {0x0306, 0xD800, 0xDD55, 'h', 'e', 'l', 'o'}); // Mix of single code unit and multi code unit code points + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codePoints(), {0x0306, 0x10155, 'h', 'e', 'l', 'o'})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codeUnits(), {0x0306, 0xD800, 0xDD55, 'h', 'e', 'l', 'o'})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).graphemeClusters(), { + StringView(b.characters16(), 1), + StringView(b.characters16() + 1, 2), + StringView(b.characters16() + 3, 1), + StringView(b.characters16() + 4, 1), + StringView(b.characters16() + 5, 1), + StringView(b.characters16() + 6, 1)})); + + build(b, {'e', 0x0301}); // "COMBINING ACUTE" + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codePoints(), {'e', 0x0301})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codeUnits(), {'e', 0x0301})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).graphemeClusters(), {StringView(b.toString())})); + + build(b, {'e', 0x0301, 0x0306, 'a'}); // "COMBINING ACUTE" "COMBINING BREVE" + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codePoints(), {'e', 0x0301, 0x0306, 'a'})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codeUnits(), {'e', 0x0301, 0x0306, 'a'})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).graphemeClusters(), { + StringView(b.characters16(), 3), + StringView(b.characters16() + 3, 1), + })); + + build(b, {0x1112, 0x116f, 0x11b6, 0x1107, 0x1161, 0x11B8}); // Korean combining Jamo + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codePoints(), {0x1112, 0x116f, 0x11b6, 0x1107, 0x1161, 0x11B8})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).codeUnits(), {0x1112, 0x116f, 0x11b6, 0x1107, 0x1161, 0x11B8})); + EXPECT_TRUE(compareLoopIterations(StringView(b.toString()).graphemeClusters(), { + StringView(b.characters16(), 3), + StringView(b.characters16() + 3, 3)})); +} + +static Vector<String> vectorFromSplitResult(const StringView::SplitResult& substrings) +{ + Vector<String> result; + for (StringView substring : substrings) + result.append(substring.toString()); + return result; +} + +TEST(WTF, StringViewSplitEmptyAndNullStrings) +{ + StringView a = emptyString(); + auto splitResult = a.split('b'); + EXPECT_TRUE(splitResult.begin() == splitResult.end()); + + a = { String { } }; + splitResult = a.split('b'); + EXPECT_TRUE(splitResult.begin() == splitResult.end()); + + a = { }; + splitResult = a.split('b'); + EXPECT_TRUE(splitResult.begin() == splitResult.end()); +} + +TEST(WTF, StringViewSplitBasic) +{ + String referenceHolder; + StringView a = stringViewFromUTF8(referenceHolder, "This is a sentence."); + + // Simple + Vector<String> actual = vectorFromSplitResult(a.split('T')); + Vector<String> expected({ "his is a sentence." }); + ASSERT_EQ(expected.size(), actual.size()); + for (size_t i = 0; i < actual.size(); ++i) + EXPECT_STREQ(expected[i].utf8().data(), actual[i].utf8().data()) << "Vectors differ at index " << i; + + actual = vectorFromSplitResult(a.split('.')); + expected = { "This is a sentence" }; + ASSERT_EQ(expected.size(), actual.size()); + for (size_t i = 0; i < actual.size(); ++i) + EXPECT_STREQ(expected[i].utf8().data(), actual[i].utf8().data()) << "Vectors differ at index " << i; + + actual = vectorFromSplitResult(a.split('a')); + expected = { "This is ", " sentence." }; + ASSERT_EQ(expected.size(), actual.size()); + for (size_t i = 0; i < actual.size(); ++i) + EXPECT_STREQ(expected[i].utf8().data(), actual[i].utf8().data()) << "Vectors differ at index " << i; + + actual = vectorFromSplitResult(a.split(' ')); + expected = { "This", "is", "a", "sentence." }; + ASSERT_EQ(expected.size(), actual.size()); + for (size_t i = 0; i < actual.size(); ++i) + EXPECT_STREQ(expected[i].utf8().data(), actual[i].utf8().data()) << "Vectors differ at index " << i; + + // Non-existent separator + actual = vectorFromSplitResult(a.split('z')); + expected = { "This is a sentence." }; + ASSERT_EQ(expected.size(), actual.size()); + for (size_t i = 0; i < actual.size(); ++i) + EXPECT_STREQ(expected[i].utf8().data(), actual[i].utf8().data()) << "Vectors differ at index " << i; +} + +TEST(WTF, StringViewSplitWithConsecutiveSeparators) +{ + String referenceHolder; + StringView a = stringViewFromUTF8(referenceHolder, "This is a sentence."); + + Vector<String> actual = vectorFromSplitResult(a.split(' ')); + Vector<String> expected({ "This", "is", "a", "sentence." }); + ASSERT_EQ(expected.size(), actual.size()); + for (size_t i = 0; i < actual.size(); ++i) + EXPECT_STREQ(expected[i].utf8().data(), actual[i].utf8().data()) << "Vectors differ at index " << i; +} + +TEST(WTF, StringViewEqualIgnoringASCIICaseBasic) +{ + RefPtr<StringImpl> a = StringImpl::createFromLiteral("aBcDeFG"); + RefPtr<StringImpl> b = StringImpl::createFromLiteral("ABCDEFG"); + RefPtr<StringImpl> c = StringImpl::createFromLiteral("abcdefg"); + const char d[] = "aBcDeFG"; + RefPtr<StringImpl> empty = StringImpl::create(reinterpret_cast<const LChar*>("")); + RefPtr<StringImpl> shorter = StringImpl::createFromLiteral("abcdef"); + RefPtr<StringImpl> different = StringImpl::createFromLiteral("abcrefg"); + + StringView stringViewA(*a.get()); + StringView stringViewB(*b.get()); + StringView stringViewC(*c.get()); + StringView emptyStringView(*empty.get()); + StringView shorterStringView(*shorter.get()); + StringView differentStringView(*different.get()); + + ASSERT_TRUE(equalIgnoringASCIICase(stringViewA, stringViewB)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewB, stringViewC)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewB, stringViewC)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewA, d)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewB, d)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewC, d)); + + // Identity. + ASSERT_TRUE(equalIgnoringASCIICase(stringViewA, stringViewA)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewB, stringViewB)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewC, stringViewC)); + + // Transitivity. + ASSERT_TRUE(equalIgnoringASCIICase(stringViewA, stringViewB)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewB, stringViewC)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewA, stringViewC)); + + // Negative cases. + ASSERT_FALSE(equalIgnoringASCIICase(stringViewA, emptyStringView)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewB, emptyStringView)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewC, emptyStringView)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewA, shorterStringView)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewB, shorterStringView)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewC, shorterStringView)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewA, differentStringView)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewB, differentStringView)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewC, differentStringView)); + ASSERT_FALSE(equalIgnoringASCIICase(emptyStringView, d)); + ASSERT_FALSE(equalIgnoringASCIICase(shorterStringView, d)); + ASSERT_FALSE(equalIgnoringASCIICase(differentStringView, d)); +} + +TEST(WTF, StringViewEqualIgnoringASCIICaseWithEmpty) +{ + RefPtr<StringImpl> a = StringImpl::create(reinterpret_cast<const LChar*>("")); + RefPtr<StringImpl> b = StringImpl::create(reinterpret_cast<const LChar*>("")); + StringView stringViewA(*a.get()); + StringView stringViewB(*b.get()); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewA, stringViewB)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewB, stringViewA)); +} + +TEST(WTF, StringViewEqualIgnoringASCIICaseWithLatin1Characters) +{ + RefPtr<StringImpl> a = StringImpl::create(reinterpret_cast<const LChar*>("aBcéeFG")); + RefPtr<StringImpl> b = StringImpl::create(reinterpret_cast<const LChar*>("ABCÉEFG")); + RefPtr<StringImpl> c = StringImpl::create(reinterpret_cast<const LChar*>("ABCéEFG")); + RefPtr<StringImpl> d = StringImpl::create(reinterpret_cast<const LChar*>("abcéefg")); + const char e[] = "aBcéeFG"; + StringView stringViewA(*a.get()); + StringView stringViewB(*b.get()); + StringView stringViewC(*c.get()); + StringView stringViewD(*d.get()); + + // Identity. + ASSERT_TRUE(equalIgnoringASCIICase(stringViewA, stringViewA)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewB, stringViewB)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewC, stringViewC)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewD, stringViewD)); + + // All combination. + ASSERT_FALSE(equalIgnoringASCIICase(stringViewA, stringViewB)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewA, stringViewC)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewA, stringViewD)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewB, stringViewC)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewB, stringViewD)); + ASSERT_TRUE(equalIgnoringASCIICase(stringViewC, stringViewD)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewA, e)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewB, e)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewC, e)); + ASSERT_FALSE(equalIgnoringASCIICase(stringViewD, e)); +} + +TEST(WTF, StringViewFindIgnoringASCIICaseBasic) +{ + String referenceAHolder; + StringView referenceA = stringViewFromUTF8(referenceAHolder, "aBcéeFG"); + String referenceBHolder; + StringView referenceB = stringViewFromUTF8(referenceBHolder, "ABCÉEFG"); + + // Search the exact string. + EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(referenceA)); + EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(referenceB)); + + // A and B are distinct by the non-ascii character é/É. + EXPECT_EQ(static_cast<size_t>(notFound), referenceA.findIgnoringASCIICase(referenceB)); + EXPECT_EQ(static_cast<size_t>(notFound), referenceB.findIgnoringASCIICase(referenceA)); + + String tempStringHolder; + // Find the prefix. + EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromLiteral("a"))); + EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcé"))); + EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromLiteral("A"))); + EXPECT_EQ(static_cast<size_t>(0), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCé"))); + EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromLiteral("a"))); + EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcÉ"))); + EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromLiteral("A"))); + EXPECT_EQ(static_cast<size_t>(0), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"))); + + // Not a prefix. + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromLiteral("x"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "accé"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcÉ"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromLiteral("X"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABDé"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromLiteral("y"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "accÉ"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "abcé"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromLiteral("Y"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABdÉ"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCé"))); + + // Find the infix. + EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cée"))); + EXPECT_EQ(static_cast<size_t>(3), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ée"))); + EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cé"))); + EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "c"))); + EXPECT_EQ(static_cast<size_t>(3), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "é"))); + EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Cée"))); + EXPECT_EQ(static_cast<size_t>(3), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éE"))); + EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Cé"))); + EXPECT_EQ(static_cast<size_t>(2), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "C"))); + + EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cÉe"))); + EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Ée"))); + EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cÉ"))); + EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "c"))); + EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "É"))); + EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "CÉe"))); + EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ÉE"))); + EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "CÉ"))); + EXPECT_EQ(static_cast<size_t>(2), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "C"))); + + // Not an infix. + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "céd"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Ée"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "bé"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "x"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "É"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "CÉe"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éd"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "CÉ"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Y"))); + + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cée"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Éc"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "cé"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "W"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "é"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "bÉe"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éE"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "BÉ"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "z"))); + + // Find the suffix. + EXPECT_EQ(static_cast<size_t>(6), referenceA.findIgnoringASCIICase(stringViewFromLiteral("g"))); + EXPECT_EQ(static_cast<size_t>(4), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "efg"))); + EXPECT_EQ(static_cast<size_t>(3), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éefg"))); + EXPECT_EQ(static_cast<size_t>(6), referenceA.findIgnoringASCIICase(stringViewFromLiteral("G"))); + EXPECT_EQ(static_cast<size_t>(4), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "EFG"))); + EXPECT_EQ(static_cast<size_t>(3), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éEFG"))); + + EXPECT_EQ(static_cast<size_t>(6), referenceB.findIgnoringASCIICase(stringViewFromLiteral("g"))); + EXPECT_EQ(static_cast<size_t>(4), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "efg"))); + EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Éefg"))); + EXPECT_EQ(static_cast<size_t>(6), referenceB.findIgnoringASCIICase(stringViewFromLiteral("G"))); + EXPECT_EQ(static_cast<size_t>(4), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "EFG"))); + EXPECT_EQ(static_cast<size_t>(3), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ÉEFG"))); + + // Not a suffix. + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromLiteral("X"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "edg"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "Éefg"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromLiteral("w"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "dFG"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ÉEFG"))); + + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromLiteral("Z"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ffg"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éefg"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromLiteral("r"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "EgG"))); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "éEFG"))); +} + +TEST(WTF, StringViewFindIgnoringASCIICaseWithValidOffset) +{ + String referenceHolder; + StringView reference = stringViewFromUTF8(referenceHolder, "ABCÉEFGaBcéeFG"); + String tempStringHolder; + + EXPECT_EQ(static_cast<size_t>(0), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABC"), 0)); + EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABC"), 1)); + EXPECT_EQ(static_cast<size_t>(0), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"), 0)); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"), 1)); + EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCé"), 0)); + EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCé"), 1)); +} + +TEST(WTF, StringViewFindIgnoringASCIICaseWithInvalidOffset) +{ + String referenceHolder; + StringView reference = stringViewFromUTF8(referenceHolder, "ABCÉEFGaBcéeFG"); + String tempStringHolder; + + EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABC"), 15)); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABC"), 16)); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"), 17)); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"), 42)); + EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(stringViewFromUTF8(tempStringHolder, "ABCÉ"), std::numeric_limits<unsigned>::max())); +} + +TEST(WTF, StringViewFindIgnoringASCIICaseOnEmpty) +{ + String referenceHolder; + StringView reference = stringViewFromUTF8(referenceHolder, "ABCÉEFG"); + StringView empty = stringViewFromLiteral(""); + EXPECT_EQ(static_cast<size_t>(0), reference.findIgnoringASCIICase(empty)); + EXPECT_EQ(static_cast<size_t>(0), reference.findIgnoringASCIICase(empty, 0)); + EXPECT_EQ(static_cast<size_t>(3), reference.findIgnoringASCIICase(empty, 3)); + EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(empty, 7)); + EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(empty, 8)); + EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(empty, 42)); + EXPECT_EQ(static_cast<size_t>(7), reference.findIgnoringASCIICase(empty, std::numeric_limits<unsigned>::max())); +} + +TEST(WTF, StringViewFindIgnoringASCIICaseWithPatternLongerThanReference) +{ + String referenceHolder; + StringView reference = stringViewFromUTF8(referenceHolder, "ABCÉEFG"); + String patternHolder; + StringView pattern = stringViewFromUTF8(patternHolder, "ABCÉEFGA"); + + EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference.findIgnoringASCIICase(pattern)); + EXPECT_EQ(static_cast<size_t>(0), pattern.findIgnoringASCIICase(reference)); +} + +TEST(WTF, StringViewStartsWithBasic) +{ + StringView reference = stringViewFromLiteral("abcdefg"); + String referenceUTF8Ref; + StringView referenceUTF8 = stringViewFromUTF8(referenceUTF8Ref, "àîûèô"); + + StringView oneLetterPrefix = stringViewFromLiteral("a"); + StringView shortPrefix = stringViewFromLiteral("abc"); + StringView longPrefix = stringViewFromLiteral("abcdef"); + StringView upperCasePrefix = stringViewFromLiteral("ABC"); + StringView empty = stringViewFromLiteral(""); + StringView notPrefix = stringViewFromLiteral("bc"); + + String oneLetterPrefixUTF8Ref; + StringView oneLetterPrefixUTF8 = stringViewFromUTF8(oneLetterPrefixUTF8Ref, "à"); + String shortPrefixUTF8Ref; + StringView shortPrefixUTF8 = stringViewFromUTF8(shortPrefixUTF8Ref, "àî"); + String longPrefixUTF8Ref; + StringView longPrefixUTF8 = stringViewFromUTF8(longPrefixUTF8Ref, "àîûè"); + String upperCasePrefixUTF8Ref; + StringView upperCasePrefixUTF8 = stringViewFromUTF8(upperCasePrefixUTF8Ref, "ÀÎ"); + String notPrefixUTF8Ref; + StringView notPrefixUTF8 = stringViewFromUTF8(notPrefixUTF8Ref, "îû"); + + EXPECT_TRUE(reference.startsWith(reference)); + EXPECT_TRUE(reference.startsWith(oneLetterPrefix)); + EXPECT_TRUE(reference.startsWith(shortPrefix)); + EXPECT_TRUE(reference.startsWith(longPrefix)); + EXPECT_TRUE(reference.startsWith(empty)); + + EXPECT_TRUE(referenceUTF8.startsWith(referenceUTF8)); + EXPECT_TRUE(referenceUTF8.startsWith(oneLetterPrefixUTF8)); + EXPECT_TRUE(referenceUTF8.startsWith(shortPrefixUTF8)); + EXPECT_TRUE(referenceUTF8.startsWith(longPrefixUTF8)); + EXPECT_TRUE(referenceUTF8.startsWith(empty)); + + EXPECT_FALSE(reference.startsWith(notPrefix)); + EXPECT_FALSE(reference.startsWith(upperCasePrefix)); + EXPECT_FALSE(reference.startsWith(notPrefixUTF8)); + EXPECT_FALSE(reference.startsWith(upperCasePrefixUTF8)); + EXPECT_FALSE(referenceUTF8.startsWith(notPrefix)); + EXPECT_FALSE(referenceUTF8.startsWith(upperCasePrefix)); + EXPECT_FALSE(referenceUTF8.startsWith(notPrefixUTF8)); + EXPECT_FALSE(referenceUTF8.startsWith(upperCasePrefixUTF8)); +} + +TEST(WTF, StringViewStartsWithEmpty) +{ + StringView a = stringViewFromLiteral(""); + String refB; + StringView b = stringViewFromUTF8(refB, ""); + + EXPECT_TRUE(a.startsWith(a)); + EXPECT_TRUE(a.startsWith(b)); + EXPECT_TRUE(b.startsWith(a)); + EXPECT_TRUE(b.startsWith(b)); +} + +TEST(WTF, StringViewStartsWithIgnoringASCIICaseBasic) +{ + StringView reference = stringViewFromLiteral("abcdefg"); + + String referenceUTF8Ref; + StringView referenceUTF8 = stringViewFromUTF8(referenceUTF8Ref, "àîûèô"); + + StringView oneLetterPrefix = stringViewFromLiteral("a"); + StringView shortPrefix = stringViewFromLiteral("abc"); + StringView longPrefix = stringViewFromLiteral("abcdef"); + StringView upperCasePrefix = stringViewFromLiteral("ABC"); + StringView mixedCasePrefix = stringViewFromLiteral("aBcDe"); + StringView empty = stringViewFromLiteral(""); + StringView notPrefix = stringViewFromLiteral("bc"); + + String oneLetterPrefixUTF8Ref; + StringView oneLetterPrefixUTF8 = stringViewFromUTF8(oneLetterPrefixUTF8Ref, "à"); + String shortPrefixUTF8Ref; + StringView shortPrefixUTF8 = stringViewFromUTF8(shortPrefixUTF8Ref, "àî"); + String longPrefixUTF8Ref; + StringView longPrefixUTF8 = stringViewFromUTF8(longPrefixUTF8Ref, "àîûè"); + String upperCasePrefixUTF8Ref; + StringView upperCasePrefixUTF8 = stringViewFromUTF8(upperCasePrefixUTF8Ref, "ÀÎ"); + String notPrefixUTF8Ref; + StringView notPrefixUTF8 = stringViewFromUTF8(notPrefixUTF8Ref, "îû"); + + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(reference)); + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(oneLetterPrefix)); + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(shortPrefix)); + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(longPrefix)); + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(empty)); + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(upperCasePrefix)); + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(mixedCasePrefix)); + + EXPECT_TRUE(referenceUTF8.startsWithIgnoringASCIICase(referenceUTF8)); + EXPECT_TRUE(referenceUTF8.startsWithIgnoringASCIICase(oneLetterPrefixUTF8)); + EXPECT_TRUE(referenceUTF8.startsWithIgnoringASCIICase(shortPrefixUTF8)); + EXPECT_TRUE(referenceUTF8.startsWithIgnoringASCIICase(longPrefixUTF8)); + EXPECT_TRUE(referenceUTF8.startsWithIgnoringASCIICase(empty)); + + EXPECT_FALSE(reference.startsWithIgnoringASCIICase(notPrefix)); + EXPECT_FALSE(reference.startsWithIgnoringASCIICase(notPrefixUTF8)); + EXPECT_FALSE(reference.startsWithIgnoringASCIICase(upperCasePrefixUTF8)); + EXPECT_FALSE(referenceUTF8.startsWithIgnoringASCIICase(notPrefix)); + EXPECT_FALSE(referenceUTF8.startsWithIgnoringASCIICase(notPrefixUTF8)); + EXPECT_FALSE(referenceUTF8.startsWithIgnoringASCIICase(upperCasePrefix)); + EXPECT_FALSE(referenceUTF8.startsWithIgnoringASCIICase(upperCasePrefixUTF8)); +} + + +TEST(WTF, StringViewStartsWithIgnoringASCIICaseEmpty) +{ + StringView a = stringViewFromLiteral(""); + String refB; + StringView b = stringViewFromUTF8(refB, ""); + + EXPECT_TRUE(a.startsWithIgnoringASCIICase(a)); + EXPECT_TRUE(a.startsWithIgnoringASCIICase(b)); + EXPECT_TRUE(b.startsWithIgnoringASCIICase(a)); + EXPECT_TRUE(b.startsWithIgnoringASCIICase(b)); +} + +TEST(WTF, StringViewStartsWithIgnoringASCIICaseWithLatin1Characters) +{ + StringView reference = stringViewFromLiteral("aBcéeFG"); + String referenceUTF8Ref; + StringView referenceUTF8 = stringViewFromUTF8(referenceUTF8Ref, "aBcéeFG"); + + StringView a = stringViewFromLiteral("aBcéeF"); + StringView b = stringViewFromLiteral("ABCéEF"); + StringView c = stringViewFromLiteral("abcéef"); + StringView d = stringViewFromLiteral("Abcéef"); + + String refE; + StringView e = stringViewFromUTF8(refE, "aBcéeF"); + String refF; + StringView f = stringViewFromUTF8(refF, "ABCéEF"); + String refG; + StringView g = stringViewFromUTF8(refG, "abcéef"); + String refH; + StringView h = stringViewFromUTF8(refH, "Abcéef"); + + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(a)); + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(b)); + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(c)); + EXPECT_TRUE(reference.startsWithIgnoringASCIICase(d)); + + EXPECT_TRUE(referenceUTF8.startsWithIgnoringASCIICase(e)); + EXPECT_TRUE(referenceUTF8.startsWithIgnoringASCIICase(f)); + EXPECT_TRUE(referenceUTF8.startsWithIgnoringASCIICase(g)); + EXPECT_TRUE(referenceUTF8.startsWithIgnoringASCIICase(h)); + + EXPECT_FALSE(reference.endsWithIgnoringASCIICase(referenceUTF8)); + EXPECT_FALSE(referenceUTF8.endsWithIgnoringASCIICase(reference)); +} + +TEST(WTF, StringViewEndsWithBasic) +{ + StringView reference = stringViewFromLiteral("abcdefg"); + String referenceUTF8Ref; + StringView referenceUTF8 = stringViewFromUTF8(referenceUTF8Ref, "àîûèô"); + + StringView oneLetterSuffix = stringViewFromLiteral("g"); + StringView shortSuffix = stringViewFromLiteral("efg"); + StringView longSuffix = stringViewFromLiteral("cdefg"); + StringView upperCaseSuffix = stringViewFromLiteral("EFG"); + StringView empty = stringViewFromLiteral(""); + StringView notSuffix = stringViewFromLiteral("bc"); + + String oneLetterSuffixUTF8Ref; + StringView oneLetterSuffixUTF8 = stringViewFromUTF8(oneLetterSuffixUTF8Ref, "ô"); + String shortSuffixUTF8Ref; + StringView shortSuffixUTF8 = stringViewFromUTF8(shortSuffixUTF8Ref, "èô"); + String longSuffixUTF8Ref; + StringView longSuffixUTF8 = stringViewFromUTF8(longSuffixUTF8Ref, "îûèô"); + String upperCaseSuffixUTF8Ref; + StringView upperCaseSuffixUTF8 = stringViewFromUTF8(upperCaseSuffixUTF8Ref, "ÈÔ"); + String notSuffixUTF8Ref; + StringView notSuffixUTF8 = stringViewFromUTF8(notSuffixUTF8Ref, "îû"); + + EXPECT_TRUE(reference.endsWith(reference)); + EXPECT_TRUE(reference.endsWith(oneLetterSuffix)); + EXPECT_TRUE(reference.endsWith(shortSuffix)); + EXPECT_TRUE(reference.endsWith(longSuffix)); + EXPECT_TRUE(reference.endsWith(empty)); + + EXPECT_TRUE(referenceUTF8.endsWith(referenceUTF8)); + EXPECT_TRUE(referenceUTF8.endsWith(oneLetterSuffixUTF8)); + EXPECT_TRUE(referenceUTF8.endsWith(shortSuffixUTF8)); + EXPECT_TRUE(referenceUTF8.endsWith(longSuffixUTF8)); + EXPECT_TRUE(referenceUTF8.endsWith(empty)); + + EXPECT_FALSE(reference.endsWith(notSuffix)); + EXPECT_FALSE(reference.endsWith(upperCaseSuffix)); + EXPECT_FALSE(reference.endsWith(notSuffixUTF8)); + EXPECT_FALSE(reference.endsWith(upperCaseSuffixUTF8)); + EXPECT_FALSE(referenceUTF8.endsWith(notSuffix)); + EXPECT_FALSE(referenceUTF8.endsWith(upperCaseSuffix)); + EXPECT_FALSE(referenceUTF8.endsWith(notSuffixUTF8)); + EXPECT_FALSE(referenceUTF8.endsWith(upperCaseSuffixUTF8)); +} + +TEST(WTF, StringViewEndsWithEmpty) +{ + StringView a = stringViewFromLiteral(""); + String refB; + StringView b = stringViewFromUTF8(refB, ""); + + EXPECT_TRUE(a.endsWith(a)); + EXPECT_TRUE(a.endsWith(b)); + EXPECT_TRUE(b.endsWith(a)); + EXPECT_TRUE(b.endsWith(b)); +} + +TEST(WTF, StringViewEndsWithIgnoringASCIICaseBasic) +{ + StringView reference = stringViewFromLiteral("abcdefg"); + String referenceUTF8Ref; + StringView referenceUTF8 = stringViewFromUTF8(referenceUTF8Ref, "àîûèô"); + + StringView oneLetterSuffix = stringViewFromLiteral("g"); + StringView shortSuffix = stringViewFromLiteral("efg"); + StringView longSuffix = stringViewFromLiteral("bcdefg"); + StringView upperCaseSuffix = stringViewFromLiteral("EFG"); + StringView mixedCaseSuffix = stringViewFromLiteral("bCdeFg"); + StringView empty = stringViewFromLiteral(""); + StringView notSuffix = stringViewFromLiteral("bc"); + + String oneLetterSuffixUTF8Ref; + StringView oneLetterSuffixUTF8 = stringViewFromUTF8(oneLetterSuffixUTF8Ref, "ô"); + String shortSuffixUTF8Ref; + StringView shortSuffixUTF8 = stringViewFromUTF8(shortSuffixUTF8Ref, "èô"); + String longSuffixUTF8Ref; + StringView longSuffixUTF8 = stringViewFromUTF8(longSuffixUTF8Ref, "îûèô"); + String upperCaseSuffixUTF8Ref; + StringView upperCaseSuffixUTF8 = stringViewFromUTF8(upperCaseSuffixUTF8Ref, "ÈÔ"); + String notSuffixUTF8Ref; + StringView notSuffixUTF8 = stringViewFromUTF8(notSuffixUTF8Ref, "îû"); + + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(reference)); + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(oneLetterSuffix)); + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(shortSuffix)); + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(longSuffix)); + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(empty)); + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(upperCaseSuffix)); + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(mixedCaseSuffix)); + + EXPECT_TRUE(referenceUTF8.endsWithIgnoringASCIICase(referenceUTF8)); + EXPECT_TRUE(referenceUTF8.endsWithIgnoringASCIICase(oneLetterSuffixUTF8)); + EXPECT_TRUE(referenceUTF8.endsWithIgnoringASCIICase(shortSuffixUTF8)); + EXPECT_TRUE(referenceUTF8.endsWithIgnoringASCIICase(longSuffixUTF8)); + EXPECT_TRUE(referenceUTF8.endsWithIgnoringASCIICase(empty)); + + EXPECT_FALSE(reference.endsWithIgnoringASCIICase(notSuffix)); + EXPECT_FALSE(reference.endsWithIgnoringASCIICase(notSuffixUTF8)); + EXPECT_FALSE(reference.endsWithIgnoringASCIICase(upperCaseSuffixUTF8)); + EXPECT_FALSE(referenceUTF8.endsWithIgnoringASCIICase(notSuffix)); + EXPECT_FALSE(referenceUTF8.endsWithIgnoringASCIICase(notSuffixUTF8)); + EXPECT_FALSE(referenceUTF8.endsWithIgnoringASCIICase(upperCaseSuffix)); + EXPECT_FALSE(referenceUTF8.endsWithIgnoringASCIICase(upperCaseSuffixUTF8)); +} + +TEST(WTF, StringViewEndsWithIgnoringASCIICaseEmpty) +{ + StringView a = stringViewFromLiteral(""); + String refB; + StringView b = stringViewFromUTF8(refB, ""); + + EXPECT_TRUE(a.endsWithIgnoringASCIICase(a)); + EXPECT_TRUE(a.endsWithIgnoringASCIICase(b)); + EXPECT_TRUE(b.endsWithIgnoringASCIICase(a)); + EXPECT_TRUE(b.endsWithIgnoringASCIICase(b)); +} + +TEST(WTF, StringViewEndsWithIgnoringASCIICaseWithLatin1Characters) +{ + StringView reference = stringViewFromLiteral("aBcéeFG"); + String referenceUTF8Ref; + StringView referenceUTF8 = stringViewFromUTF8(referenceUTF8Ref, "aBcéeFG"); + + StringView a = stringViewFromLiteral("BcéeFG"); + StringView b = stringViewFromLiteral("BCéEFG"); + StringView c = stringViewFromLiteral("bcéefG"); + StringView d = stringViewFromLiteral("bcéefg"); + + String refE; + StringView e = stringViewFromUTF8(refE, "bcéefG"); + String refF; + StringView f = stringViewFromUTF8(refF, "BCéEFG"); + String refG; + StringView g = stringViewFromUTF8(refG, "bcéefG"); + String refH; + StringView h = stringViewFromUTF8(refH, "bcéefg"); + + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(a)); + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(b)); + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(c)); + EXPECT_TRUE(reference.endsWithIgnoringASCIICase(d)); + + EXPECT_TRUE(referenceUTF8.endsWithIgnoringASCIICase(e)); + EXPECT_TRUE(referenceUTF8.endsWithIgnoringASCIICase(f)); + EXPECT_TRUE(referenceUTF8.endsWithIgnoringASCIICase(g)); + EXPECT_TRUE(referenceUTF8.endsWithIgnoringASCIICase(h)); + + EXPECT_FALSE(reference.endsWithIgnoringASCIICase(referenceUTF8)); + EXPECT_FALSE(referenceUTF8.endsWithIgnoringASCIICase(reference)); +} + +TEST(WTF, StringView8Bit) +{ + StringView nullView; + EXPECT_TRUE(StringView().is8Bit()); + EXPECT_TRUE(StringView::empty().is8Bit()); + + LChar* lcharPtr = nullptr; + UChar* ucharPtr = nullptr; + EXPECT_TRUE(StringView(lcharPtr, 0).is8Bit()); + EXPECT_FALSE(StringView(ucharPtr, 0).is8Bit()); + + EXPECT_TRUE(StringView(String(lcharPtr, 0)).is8Bit()); + EXPECT_TRUE(StringView(String(ucharPtr, 0)).is8Bit()); + + EXPECT_TRUE(StringView(String().impl()).is8Bit()); + EXPECT_TRUE(StringView(emptyString().impl()).is8Bit()); +} + +TEST(WTF, StringViewRightBasic) +{ + auto reference = stringViewFromLiteral("Cappuccino"); + EXPECT_TRUE(reference.right(0) == stringViewFromLiteral("")); + EXPECT_TRUE(reference.right(1) == stringViewFromLiteral("o")); + EXPECT_TRUE(reference.right(2) == stringViewFromLiteral("no")); + EXPECT_TRUE(reference.right(3) == stringViewFromLiteral("ino")); + EXPECT_TRUE(reference.right(4) == stringViewFromLiteral("cino")); + EXPECT_TRUE(reference.right(5) == stringViewFromLiteral("ccino")); + EXPECT_TRUE(reference.right(6) == stringViewFromLiteral("uccino")); + EXPECT_TRUE(reference.right(7) == stringViewFromLiteral("puccino")); + EXPECT_TRUE(reference.right(8) == stringViewFromLiteral("ppuccino")); + EXPECT_TRUE(reference.right(9) == stringViewFromLiteral("appuccino")); + EXPECT_TRUE(reference.right(10) == stringViewFromLiteral("Cappuccino")); +} + +TEST(WTF, StringViewLeftBasic) +{ + auto reference = stringViewFromLiteral("Cappuccino"); + EXPECT_TRUE(reference.left(0) == stringViewFromLiteral("")); + EXPECT_TRUE(reference.left(1) == stringViewFromLiteral("C")); + EXPECT_TRUE(reference.left(2) == stringViewFromLiteral("Ca")); + EXPECT_TRUE(reference.left(3) == stringViewFromLiteral("Cap")); + EXPECT_TRUE(reference.left(4) == stringViewFromLiteral("Capp")); + EXPECT_TRUE(reference.left(5) == stringViewFromLiteral("Cappu")); + EXPECT_TRUE(reference.left(6) == stringViewFromLiteral("Cappuc")); + EXPECT_TRUE(reference.left(7) == stringViewFromLiteral("Cappucc")); + EXPECT_TRUE(reference.left(8) == stringViewFromLiteral("Cappucci")); + EXPECT_TRUE(reference.left(9) == stringViewFromLiteral("Cappuccin")); + EXPECT_TRUE(reference.left(10) == stringViewFromLiteral("Cappuccino")); +} + +TEST(WTF, StringViewReverseFindBasic) +{ + auto reference = stringViewFromLiteral("Cappuccino"); + EXPECT_EQ(reference.reverseFind('o'), 9U); + EXPECT_EQ(reference.reverseFind('n'), 8U); + EXPECT_EQ(reference.reverseFind('c'), 6U); + EXPECT_EQ(reference.reverseFind('p'), 3U); + EXPECT_EQ(reference.reverseFind('k'), notFound); + + EXPECT_EQ(reference.reverseFind('o', 8), notFound); + EXPECT_EQ(reference.reverseFind('c', 8), 6U); + EXPECT_EQ(reference.reverseFind('c', 6), 6U); + EXPECT_EQ(reference.reverseFind('c', 5), 5U); + EXPECT_EQ(reference.reverseFind('c', 4), notFound); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/SynchronizedFixedQueue.cpp b/Tools/TestWebKitAPI/Tests/WTF/SynchronizedFixedQueue.cpp new file mode 100644 index 000000000..31436bc22 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/SynchronizedFixedQueue.cpp @@ -0,0 +1,229 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <chrono> +#include <thread> + +#include <wtf/ASCIICType.h> +#include <wtf/SynchronizedFixedQueue.h> +#include <wtf/WorkQueue.h> +#include <wtf/text/CString.h> +#include <wtf/threads/BinarySemaphore.h> + +namespace TestWebKitAPI { + +static char const* textItem(size_t index) +{ + static char const* items[] = { "first", "second", "third", "fourth", "fifth", "sixth" }; + return index < sizeof(items) / sizeof(items[0]) ? items[index] : nullptr; +} + +static CString toUpper(const CString& lower) +{ + CString upper = lower; + + for (char* buffer = upper.mutableData(); *buffer; ++buffer) + *buffer = toASCIIUpper(*buffer); + + return upper; +} + +template <size_t BufferSize> +class ToUpperConverter { +public: + ToUpperConverter() + { + } + + WorkQueue* produceQueue() + { + if (!m_produceQueue) + m_produceQueue = WorkQueue::create("org.webkit.Produce"); + return m_produceQueue.get(); + } + + WorkQueue* consumeQueue() + { + if (!m_consumeQueue) + m_consumeQueue = WorkQueue::create("org.webkit.Consume"); + return m_consumeQueue.get(); + } + + void startProducing() + { + if (isProducing()) + return; + + produceQueue()->dispatch([this] { + CString lower; + while (m_lowerQueue.dequeue(lower)) { + m_upperQueue.enqueue(toUpper(lower)); + EXPECT_TRUE(lower == textItem(m_produceCount++)); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } + m_produceCloseSemaphore.signal(); + }); + } + + void startConsuming() + { + if (isConsuming()) + return; + + consumeQueue()->dispatch([this] { + CString upper; + while (m_upperQueue.dequeue(upper)) { + EXPECT_TRUE(upper == toUpper(textItem(m_consumeCount++))); + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + } + m_consumeCloseSemaphore.signal(); + }); + } + + void start() + { + startProducing(); + startConsuming(); + } + + void stopProducing() + { + if (!isProducing()) + return; + + m_lowerQueue.close(); + m_produceCloseSemaphore.wait(WallTime::infinity()); + m_produceQueue = nullptr; + } + + void stopConsuming() + { + if (!isConsuming()) + return; + + m_upperQueue.close(); + m_consumeCloseSemaphore.wait(WallTime::infinity()); + m_consumeQueue = nullptr; + } + + void stop() + { + stopProducing(); + stopConsuming(); + } + + void enqueueLower(const CString& lower) + { + m_lowerQueue.enqueue(lower); + } + + bool isProducing() { return m_produceQueue; } + bool isConsuming() { return m_consumeQueue; } + + size_t produceCount() const { return m_produceCount; } + size_t consumeCount() const { return m_consumeCount; } + +private: + SynchronizedFixedQueue<CString, BufferSize> m_lowerQueue; + SynchronizedFixedQueue<CString, BufferSize> m_upperQueue; + RefPtr<WorkQueue> m_produceQueue; + RefPtr<WorkQueue> m_consumeQueue; + BinarySemaphore m_produceCloseSemaphore; + BinarySemaphore m_consumeCloseSemaphore; + size_t m_produceCount { 0 }; + size_t m_consumeCount { 0 }; +}; + +TEST(WTF_SynchronizedFixedQueue, Basic) +{ + ToUpperConverter<4U> converter; + + converter.start(); + EXPECT_TRUE(converter.isProducing() && converter.isConsuming()); + + converter.stop(); + EXPECT_FALSE(converter.isProducing() || converter.isConsuming()); + + EXPECT_EQ(converter.produceCount(), 0U); + EXPECT_EQ(converter.consumeCount(), 0U); +} + +TEST(WTF_SynchronizedFixedQueue, ProduceOnly) +{ + ToUpperConverter<4U> converter; + + converter.startProducing(); + EXPECT_TRUE(converter.isProducing() && !converter.isConsuming()); + + size_t count = 0; + while (char const* item = textItem(count)) { + converter.enqueueLower(item); + ++count; + + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + converter.stop(); + EXPECT_FALSE(converter.isProducing() || converter.isConsuming()); +} + +TEST(WTF_SynchronizedFixedQueue, ConsumeOnly) +{ + ToUpperConverter<4U> converter; + + converter.startConsuming(); + EXPECT_TRUE(!converter.isProducing() && converter.isConsuming()); + + converter.stop(); + EXPECT_FALSE(converter.isProducing() || converter.isConsuming()); +} + +TEST(WTF_SynchronizedFixedQueue, Limits) +{ + ToUpperConverter<4U> converter; + + converter.start(); + EXPECT_TRUE(converter.isProducing() && converter.isConsuming()); + + size_t count = 0; + while (char const* item = textItem(count)) { + converter.enqueueLower(item); + ++count; + + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + std::this_thread::sleep_for(std::chrono::milliseconds(400)); + + converter.stop(); + EXPECT_FALSE(converter.isProducing() || converter.isConsuming()); + + EXPECT_EQ(converter.produceCount(), count); + EXPECT_EQ(converter.consumeCount(), count); +} + +} diff --git a/Tools/TestWebKitAPI/Tests/WTF/TextBreakIterator.cpp b/Tools/TestWebKitAPI/Tests/WTF/TextBreakIterator.cpp new file mode 100644 index 000000000..c2f84e3d7 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/TextBreakIterator.cpp @@ -0,0 +1,146 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <wtf/text/TextBreakIterator.h> + +namespace TestWebKitAPI { + +static String makeUTF16(std::vector<UChar> input) +{ + return { input.data(), static_cast<unsigned>(input.size()) }; +} + +TEST(WTF, TextBreakIteratorNumGraphemeClusters) +{ + EXPECT_EQ(0U, numGraphemeClusters(StringView { })); + EXPECT_EQ(0U, numGraphemeClusters(StringView { "" })); + EXPECT_EQ(0U, numGraphemeClusters(makeUTF16({ }))); + + EXPECT_EQ(1U, numGraphemeClusters(StringView { "a" })); + EXPECT_EQ(1U, numGraphemeClusters(makeUTF16({ 'a' }))); + EXPECT_EQ(1U, numGraphemeClusters(StringView { "\r\n" })); + EXPECT_EQ(1U, numGraphemeClusters(StringView { "\n" })); + EXPECT_EQ(1U, numGraphemeClusters(StringView { "\r" })); + EXPECT_EQ(1U, numGraphemeClusters(makeUTF16({ '\r', '\n' }))); + EXPECT_EQ(1U, numGraphemeClusters(makeUTF16({ '\n' }))); + EXPECT_EQ(1U, numGraphemeClusters(makeUTF16({ '\r' }))); + + EXPECT_EQ(2U, numGraphemeClusters(StringView { "\n\r" })); + EXPECT_EQ(2U, numGraphemeClusters(makeUTF16({ '\n', '\r' }))); + + EXPECT_EQ(2U, numGraphemeClusters(StringView { "\r\n\r" })); + EXPECT_EQ(2U, numGraphemeClusters(makeUTF16({ '\r', '\n', '\r' }))); + + EXPECT_EQ(1U, numGraphemeClusters(makeUTF16({ 'g', 0x308 }))); + EXPECT_EQ(1U, numGraphemeClusters(makeUTF16({ 0x1100, 0x1161, 0x11A8 }))); + EXPECT_EQ(1U, numGraphemeClusters(makeUTF16({ 0x0BA8, 0x0BBF }))); + + EXPECT_EQ(2U, numGraphemeClusters(makeUTF16({ 0x308, 'g' }))); + + EXPECT_EQ(3U, numGraphemeClusters(StringView { "\r\nbc" })); + EXPECT_EQ(3U, numGraphemeClusters(makeUTF16({ 'g', 0x308, 'b', 'c' }))); +} + +TEST(WTF, TextBreakIteratorNumCharactersInGraphemeClusters) +{ + EXPECT_EQ(0U, numCharactersInGraphemeClusters(StringView { }, 0)); + EXPECT_EQ(0U, numCharactersInGraphemeClusters(StringView { }, 1)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(StringView { "" }, 0)); + EXPECT_EQ(0U, numCharactersInGraphemeClusters(StringView { "" }, 1)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(makeUTF16({ }), 0)); + EXPECT_EQ(0U, numCharactersInGraphemeClusters(makeUTF16({ }), 1)); + + EXPECT_EQ(1U, numCharactersInGraphemeClusters(StringView { "a" }, 1)); + EXPECT_EQ(1U, numCharactersInGraphemeClusters(makeUTF16({ 'a' }), 1)); + EXPECT_EQ(1U, numCharactersInGraphemeClusters(StringView { "\n" }, 1)); + EXPECT_EQ(1U, numCharactersInGraphemeClusters(StringView { "\r" }, 1)); + EXPECT_EQ(1U, numCharactersInGraphemeClusters(makeUTF16({ '\n' }), 1)); + EXPECT_EQ(1U, numCharactersInGraphemeClusters(makeUTF16({ '\r' }), 1)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(StringView { "abc" }, 0)); + EXPECT_EQ(1U, numCharactersInGraphemeClusters(StringView { "abc" }, 1)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(StringView { "abc" }, 2)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(StringView { "abc" }, 3)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(StringView { "abc" }, 4)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(makeUTF16({ 'a', 'b', 'c' }), 0)); + EXPECT_EQ(1U, numCharactersInGraphemeClusters(makeUTF16({ 'a', 'b', 'c' }), 1)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(makeUTF16({ 'a', 'b', 'c' }), 2)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(makeUTF16({ 'a', 'b', 'c' }), 3)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(makeUTF16({ 'a', 'b', 'c' }), 4)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(StringView { "\r\n" }, 0)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(StringView { "\r\n" }, 1)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(StringView { "\r\n" }, 2)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(StringView { "\r\n" }, 3)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(makeUTF16({ '\r', '\n' }), 0)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(makeUTF16({ '\r', '\n' }), 1)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(makeUTF16({ '\r', '\n' }), 2)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(makeUTF16({ '\r', '\n' }), 3)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(StringView { "\n\r" }, 0)); + EXPECT_EQ(1U, numCharactersInGraphemeClusters(StringView { "\n\r" }, 1)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(StringView { "\n\r" }, 2)); + + EXPECT_EQ(1U, numCharactersInGraphemeClusters(makeUTF16({ '\n', '\r' }), 1)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(makeUTF16({ '\n', '\r' }), 2)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(StringView { "\r\n\r" }, 0)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(StringView { "\r\n\r" }, 1)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(StringView { "\r\n\r" }, 2)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(StringView { "\r\n\r" }, 3)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(makeUTF16({ '\r', '\n', '\r' }), 0)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(makeUTF16({ '\r', '\n', '\r' }), 1)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(makeUTF16({ '\r', '\n', '\r' }), 2)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(makeUTF16({ '\r', '\n', '\r' }), 3)); + + EXPECT_EQ(2U, numCharactersInGraphemeClusters(makeUTF16({ 'g', 0x308 }), 1)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(makeUTF16({ 0x1100, 0x1161, 0x11A8 }), 1)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(makeUTF16({ 0x0BA8, 0x0BBF }), 1)); + + EXPECT_EQ(1U, numCharactersInGraphemeClusters(makeUTF16({ 0x308, 'g' }), 1)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(StringView { "\r\nbc" }, 0)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(StringView { "\r\nbc" }, 1)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(StringView { "\r\nbc" }, 2)); + EXPECT_EQ(4U, numCharactersInGraphemeClusters(StringView { "\r\nbc" }, 3)); + EXPECT_EQ(4U, numCharactersInGraphemeClusters(StringView { "\r\nbc" }, 4)); + EXPECT_EQ(4U, numCharactersInGraphemeClusters(StringView { "\r\nbc" }, 5)); + + EXPECT_EQ(0U, numCharactersInGraphemeClusters(makeUTF16({ 'g', 0x308, 'b', 'c' }), 0)); + EXPECT_EQ(2U, numCharactersInGraphemeClusters(makeUTF16({ 'g', 0x308, 'b', 'c' }), 1)); + EXPECT_EQ(3U, numCharactersInGraphemeClusters(makeUTF16({ 'g', 0x308, 'b', 'c' }), 2)); + EXPECT_EQ(4U, numCharactersInGraphemeClusters(makeUTF16({ 'g', 0x308, 'b', 'c' }), 3)); + EXPECT_EQ(4U, numCharactersInGraphemeClusters(makeUTF16({ 'g', 0x308, 'b', 'c' }), 4)); + EXPECT_EQ(4U, numCharactersInGraphemeClusters(makeUTF16({ 'g', 0x308, 'b', 'c' }), 5)); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/Time.cpp b/Tools/TestWebKitAPI/Tests/WTF/Time.cpp new file mode 100644 index 000000000..52e71494b --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/Time.cpp @@ -0,0 +1,318 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include <wtf/ClockType.h> +#include <wtf/MonotonicTime.h> +#include <wtf/Seconds.h> +#include <wtf/StringPrintStream.h> +#include <wtf/TimeWithDynamicClockType.h> +#include <wtf/WallTime.h> + +namespace WTF { + +std::basic_ostream<char>& operator<<(std::basic_ostream<char>& out, Seconds value) +{ + out << toCString(value).data(); + return out; +} + +std::basic_ostream<char>& operator<<(std::basic_ostream<char>& out, WallTime value) +{ + out << toCString(value).data(); + return out; +} + +std::basic_ostream<char>& operator<<(std::basic_ostream<char>& out, MonotonicTime value) +{ + out << toCString(value).data(); + return out; +} + +std::basic_ostream<char>& operator<<(std::basic_ostream<char>& out, TimeWithDynamicClockType value) +{ + out << toCString(value).data(); + return out; +} + +} // namespace WTF + +using namespace WTF; + +namespace TestWebKitAPI { + +namespace { + +Seconds s(double value) +{ + return Seconds(value); +} + +WallTime wt(double value) +{ + return WallTime::fromRawSeconds(value); +} + +MonotonicTime mt(double value) +{ + return MonotonicTime::fromRawSeconds(value); +} + +TimeWithDynamicClockType dt(double value, ClockType type) +{ + return TimeWithDynamicClockType::fromRawSeconds(value, type); +} + +TimeWithDynamicClockType dtw(double value) +{ + return dt(value, ClockType::Wall); +} + +TimeWithDynamicClockType dtm(double value) +{ + return dt(value, ClockType::Monotonic); +} + +} // anonymous namespace + +TEST(WTF_Time, units) +{ + EXPECT_EQ(s(60), Seconds::fromMinutes(1)); + EXPECT_EQ(s(0.001), Seconds::fromMilliseconds(1)); + EXPECT_EQ(s(0.000001), Seconds::fromMicroseconds(1)); + EXPECT_EQ(s(0.0000005), Seconds::fromNanoseconds(500)); + + EXPECT_EQ(s(120).minutes(), 2); + EXPECT_EQ(s(2).seconds(), 2); + EXPECT_EQ(s(2).milliseconds(), 2000); + EXPECT_EQ(s(2).microseconds(), 2000000); + EXPECT_EQ(s(2).nanoseconds(), 2000000000); +} + +TEST(WTF_Time, plus) +{ + EXPECT_EQ(s(6), s(1) + s(5)); + EXPECT_EQ(s(6), s(5) + s(1)); + EXPECT_EQ(wt(6), s(1) + wt(5)); + EXPECT_EQ(wt(6), s(5) + wt(1)); + EXPECT_EQ(wt(6), wt(1) + s(5)); + EXPECT_EQ(wt(6), wt(5) + s(1)); + EXPECT_EQ(mt(6), s(1) + mt(5)); + EXPECT_EQ(mt(6), s(5) + mt(1)); + EXPECT_EQ(mt(6), mt(1) + s(5)); + EXPECT_EQ(mt(6), mt(5) + s(1)); + EXPECT_EQ(dtw(6), s(1) + dtw(5)); + EXPECT_EQ(dtw(6), s(5) + dtw(1)); + EXPECT_EQ(dtw(6), dtw(1) + s(5)); + EXPECT_EQ(dtw(6), dtw(5) + s(1)); + EXPECT_EQ(dtm(6), s(1) + dtm(5)); + EXPECT_EQ(dtm(6), s(5) + dtm(1)); + EXPECT_EQ(dtm(6), dtm(1) + s(5)); + EXPECT_EQ(dtm(6), dtm(5) + s(1)); +} + +TEST(WTF_Time, minus) +{ + EXPECT_EQ(s(-4), s(1) - s(5)); + EXPECT_EQ(s(4), s(5) - s(1)); + EXPECT_EQ(wt(-4), s(1) - wt(5)); + EXPECT_EQ(wt(4), s(5) - wt(1)); + EXPECT_EQ(wt(-4), wt(1) - s(5)); + EXPECT_EQ(wt(4), wt(5) - s(1)); + EXPECT_EQ(mt(-4), s(1) - mt(5)); + EXPECT_EQ(mt(4), s(5) - mt(1)); + EXPECT_EQ(mt(-4), mt(1) - s(5)); + EXPECT_EQ(mt(4), mt(5) - s(1)); + EXPECT_EQ(dtw(-4), s(1) - dtw(5)); + EXPECT_EQ(dtw(4), s(5) - dtw(1)); + EXPECT_EQ(dtw(-4), dtw(1) - s(5)); + EXPECT_EQ(dtw(4), dtw(5) - s(1)); + EXPECT_EQ(dtm(-4), s(1) - dtm(5)); + EXPECT_EQ(dtm(4), s(5) - dtm(1)); + EXPECT_EQ(dtm(-4), dtm(1) - s(5)); + EXPECT_EQ(dtm(4), dtm(5) - s(1)); +} + +TEST(WTF_Time, negate) +{ + EXPECT_EQ(s(-7), -s(7)); + EXPECT_EQ(s(7), -s(-7)); + EXPECT_EQ(wt(-7), -wt(7)); + EXPECT_EQ(wt(7), -wt(-7)); + EXPECT_EQ(mt(-7), -mt(7)); + EXPECT_EQ(mt(7), -mt(-7)); + EXPECT_EQ(dtw(-7), -dtw(7)); + EXPECT_EQ(dtw(7), -dtw(-7)); + EXPECT_EQ(dtm(-7), -dtm(7)); + EXPECT_EQ(dtm(7), -dtm(-7)); +} + +TEST(WTF_Time, times) +{ + EXPECT_EQ(s(15), s(3) * 5); +} + +TEST(WTF_Time, divide) +{ + EXPECT_EQ(s(3), s(15) / 5); +} + +TEST(WTF_Time, less) +{ + EXPECT_FALSE(s(2) < s(1)); + EXPECT_FALSE(s(2) < s(2)); + EXPECT_TRUE(s(2) < s(3)); + EXPECT_FALSE(wt(2) < wt(1)); + EXPECT_FALSE(wt(2) < wt(2)); + EXPECT_TRUE(wt(2) < wt(3)); + EXPECT_FALSE(mt(2) < mt(1)); + EXPECT_FALSE(mt(2) < mt(2)); + EXPECT_TRUE(mt(2) < mt(3)); + EXPECT_FALSE(dtw(2) < dtw(1)); + EXPECT_FALSE(dtw(2) < dtw(2)); + EXPECT_TRUE(dtw(2) < dtw(3)); + EXPECT_FALSE(dtm(2) < dtm(1)); + EXPECT_FALSE(dtm(2) < dtm(2)); + EXPECT_TRUE(dtm(2) < dtm(3)); +} + +TEST(WTF_Time, lessEqual) +{ + EXPECT_FALSE(s(2) <= s(1)); + EXPECT_TRUE(s(2) <= s(2)); + EXPECT_TRUE(s(2) <= s(3)); + EXPECT_FALSE(wt(2) <= wt(1)); + EXPECT_TRUE(wt(2) <= wt(2)); + EXPECT_TRUE(wt(2) <= wt(3)); + EXPECT_FALSE(mt(2) <= mt(1)); + EXPECT_TRUE(mt(2) <= mt(2)); + EXPECT_TRUE(mt(2) <= mt(3)); + EXPECT_FALSE(dtw(2) <= dtw(1)); + EXPECT_TRUE(dtw(2) <= dtw(2)); + EXPECT_TRUE(dtw(2) <= dtw(3)); + EXPECT_FALSE(dtm(2) <= dtm(1)); + EXPECT_TRUE(dtm(2) <= dtm(2)); + EXPECT_TRUE(dtm(2) <= dtm(3)); +} + +TEST(WTF_Time, greater) +{ + EXPECT_TRUE(s(2) > s(1)); + EXPECT_FALSE(s(2) > s(2)); + EXPECT_FALSE(s(2) > s(3)); + EXPECT_TRUE(wt(2) > wt(1)); + EXPECT_FALSE(wt(2) > wt(2)); + EXPECT_FALSE(wt(2) > wt(3)); + EXPECT_TRUE(mt(2) > mt(1)); + EXPECT_FALSE(mt(2) > mt(2)); + EXPECT_FALSE(mt(2) > mt(3)); + EXPECT_TRUE(dtw(2) > dtw(1)); + EXPECT_FALSE(dtw(2) > dtw(2)); + EXPECT_FALSE(dtw(2) > dtw(3)); + EXPECT_TRUE(dtm(2) > dtm(1)); + EXPECT_FALSE(dtm(2) > dtm(2)); + EXPECT_FALSE(dtm(2) > dtm(3)); +} + +TEST(WTF_Time, greaterEqual) +{ + EXPECT_TRUE(s(2) >= s(1)); + EXPECT_TRUE(s(2) >= s(2)); + EXPECT_FALSE(s(2) >= s(3)); + EXPECT_TRUE(wt(2) >= wt(1)); + EXPECT_TRUE(wt(2) >= wt(2)); + EXPECT_FALSE(wt(2) >= wt(3)); + EXPECT_TRUE(mt(2) >= mt(1)); + EXPECT_TRUE(mt(2) >= mt(2)); + EXPECT_FALSE(mt(2) >= mt(3)); + EXPECT_TRUE(dtw(2) >= dtw(1)); + EXPECT_TRUE(dtw(2) >= dtw(2)); + EXPECT_FALSE(dtw(2) >= dtw(3)); + EXPECT_TRUE(dtm(2) >= dtm(1)); + EXPECT_TRUE(dtm(2) >= dtm(2)); + EXPECT_FALSE(dtm(2) >= dtm(3)); +} + +TEST(WTF_Time, equal) +{ + EXPECT_FALSE(s(2) == s(1)); + EXPECT_TRUE(s(2) == s(2)); + EXPECT_FALSE(s(2) == s(3)); + EXPECT_FALSE(wt(2) == wt(1)); + EXPECT_TRUE(wt(2) == wt(2)); + EXPECT_FALSE(wt(2) == wt(3)); + EXPECT_FALSE(mt(2) == mt(1)); + EXPECT_TRUE(mt(2) == mt(2)); + EXPECT_FALSE(mt(2) == mt(3)); + EXPECT_FALSE(dtw(2) == dtw(1)); + EXPECT_TRUE(dtw(2) == dtw(2)); + EXPECT_FALSE(dtw(2) == dtw(3)); + EXPECT_FALSE(dtm(2) == dtm(1)); + EXPECT_TRUE(dtm(2) == dtm(2)); + EXPECT_FALSE(dtm(2) == dtm(3)); +} + +TEST(WTF_Time, notEqual) +{ + EXPECT_TRUE(s(2) != s(1)); + EXPECT_FALSE(s(2) != s(2)); + EXPECT_TRUE(s(2) != s(3)); + EXPECT_TRUE(wt(2) != wt(1)); + EXPECT_FALSE(wt(2) != wt(2)); + EXPECT_TRUE(wt(2) != wt(3)); + EXPECT_TRUE(mt(2) != mt(1)); + EXPECT_FALSE(mt(2) != mt(2)); + EXPECT_TRUE(mt(2) != mt(3)); + EXPECT_TRUE(dtw(2) != dtw(1)); + EXPECT_FALSE(dtw(2) != dtw(2)); + EXPECT_TRUE(dtw(2) != dtw(3)); + EXPECT_TRUE(dtm(2) != dtm(1)); + EXPECT_FALSE(dtm(2) != dtm(2)); + EXPECT_TRUE(dtm(2) != dtm(3)); +} + +TEST(WTF_Time, literals) +{ + EXPECT_TRUE(s(120) == 2_min); + EXPECT_TRUE(s(2) == 2_s); + EXPECT_TRUE(s(2) == 2000_ms); + EXPECT_TRUE(s(2) - 1000_ms == s(1)); + EXPECT_TRUE(2_s - s(1) == 1000_ms); + + EXPECT_TRUE(Seconds::fromMinutes(2) == 2_min); + EXPECT_TRUE(Seconds(2) == 2_s); + EXPECT_TRUE(Seconds::fromMilliseconds(2) == 2_ms); + EXPECT_TRUE(Seconds::fromMicroseconds(2) == 2_us); + EXPECT_TRUE(Seconds::fromNanoseconds(2) == 2_ns); + + EXPECT_TRUE(Seconds::fromMinutes(2.5) == 2.5_min); + EXPECT_TRUE(Seconds(2.5) == 2.5_s); + EXPECT_TRUE(Seconds::fromMilliseconds(2.5) == 2.5_ms); + EXPECT_TRUE(Seconds::fromMicroseconds(2.5) == 2.5_us); + EXPECT_TRUE(Seconds::fromNanoseconds(2.5) == 2.5_ns); +} + +} // namespace TestWebKitAPI + diff --git a/Tools/TestWebKitAPI/Tests/WTF/UniqueRef.cpp b/Tools/TestWebKitAPI/Tests/WTF/UniqueRef.cpp new file mode 100644 index 000000000..4d2b22aa5 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/UniqueRef.cpp @@ -0,0 +1,93 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <wtf/UniqueRef.h> +#include <wtf/Vector.h> + +namespace TestWebKitAPI { + +class A { }; +class B { +public: + B(int a, int b, int c) + : a(a) + , b(b) + , c(c) + { }; + int a; + int b; + int c; +}; +class C { +public: + C(UniqueRef<A>&& a) + : a(WTFMove(a)) + { } + UniqueRef<A> a; +}; +class D : public A { }; + +void function(const UniqueRef<A> a) +{ + const A& b = a.get(); + const A* c = &a; + UNUSED_PARAM(b); + UNUSED_PARAM(c); +} + +TEST(WTF, UniqueRef) +{ + UniqueRef<A> a = makeUniqueRef<A>(); + UniqueRef<B> b = makeUniqueRef<B>(1, 2, 3); + B& c = b.get(); + const B& d = b.get(); + B* e = &b; + const B* f = &b; + UniqueRef<A> j = WTFMove(a); + + Vector<UniqueRef<B>> v; + v.append(makeUniqueRef<B>(4, 5, 6)); + v.append(makeUniqueRef<B>(7, 8, 9)); + UniqueRef<B> g = v.takeLast(); + ASSERT_EQ(g->b, 8); + ASSERT_EQ(v.last()->b, 5); + + C h(makeUniqueRef<A>()); + C i(makeUniqueRef<D>()); + + UNUSED_PARAM(b); + UNUSED_PARAM(c); + UNUSED_PARAM(d); + UNUSED_PARAM(e); + UNUSED_PARAM(f); + UNUSED_PARAM(g); + UNUSED_PARAM(h); + UNUSED_PARAM(i); + UNUSED_PARAM(j); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/Variant.cpp b/Tools/TestWebKitAPI/Tests/WTF/Variant.cpp new file mode 100644 index 000000000..b68156179 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/Variant.cpp @@ -0,0 +1,228 @@ +/* + * Copyright (C) 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 + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "Counters.h" +#include "RefLogger.h" +#include <wtf/Ref.h> +#include <wtf/RefPtr.h> +#include <wtf/StdLibExtras.h> +#include <wtf/Variant.h> +#include <wtf/text/WTFString.h> + +namespace TestWebKitAPI { + +TEST(WTF_Variant, Initial) +{ + Variant<int, double> v1; + EXPECT_TRUE(v1.index() == 0); + EXPECT_TRUE(WTF::get<int>(v1) == 0); + + struct T { + T() : value(15) { } + int value; + }; + + Variant<T, int> v2; + EXPECT_TRUE(v2.index() == 0); + EXPECT_TRUE(WTF::get<T>(v2).value == 15); +} + +TEST(WTF_Variant, Basic) +{ + Variant<int, double> variant = 1; + EXPECT_TRUE(variant.index() == 0); + EXPECT_TRUE(WTF::get<int>(variant) == 1); + EXPECT_TRUE(*WTF::get_if<int>(variant) == 1); + EXPECT_TRUE(WTF::get_if<double>(variant) == nullptr); + EXPECT_TRUE(WTF::holds_alternative<int>(variant)); + EXPECT_FALSE(WTF::holds_alternative<double>(variant)); + + variant = 1.0; + EXPECT_TRUE(variant.index() == 1); + EXPECT_TRUE(WTF::get<double>(variant) == 1); + EXPECT_TRUE(*WTF::get_if<double>(variant) == 1.0); + EXPECT_TRUE(WTF::get_if<int>(variant) == nullptr); + EXPECT_TRUE(WTF::holds_alternative<double>(variant)); + EXPECT_FALSE(WTF::holds_alternative<int>(variant)); +} + +TEST(WTF_Variant, BasicVisitor) +{ + enum class Type { + None, + Int, + Float, + String, + }; + + struct Visitor { + Visitor(Type& t) + : type(t) + { + } + + Type& type; + + void operator()(int) const { type = Type::Int; } + void operator()(float) const { type = Type::Float; } + void operator()(String) const { type = Type::String; } + }; + + Type type = Type::None; + + Variant<int, float, String> variant = 8; + WTF::visit(Visitor(type), variant); + EXPECT_TRUE(Type::Int == type); + + + variant = 1.0f; + WTF::visit(Visitor(type), variant); + EXPECT_TRUE(Type::Float == type); + + + variant = "hello"; + WTF::visit(Visitor(type), variant); + EXPECT_TRUE(Type::String == type); +} + +TEST(WTF_Variant, VisitorUsingMakeVisitor) +{ + enum class Type { + None, + Int, + Float, + String, + }; + + Type type = Type::None; + + auto visitor = WTF::makeVisitor( + [&](int) { type = Type::Int; }, + [&](float) { type = Type::Float; }, + [&](String) { type = Type::String; } + ); + + Variant<int, float, String> variant = 8; + WTF::visit(visitor, variant); + EXPECT_TRUE(Type::Int == type); + + + variant = 1.0f; + WTF::visit(visitor, variant); + EXPECT_TRUE(Type::Float == type); + + + variant = "hello"; + WTF::visit(visitor, variant); + EXPECT_TRUE(Type::String == type); +} + +TEST(WTF_Variant, VisitorUsingSwitchOn) +{ + enum class Type { + None, + Int, + Float, + String, + }; + + Type type = Type::None; + + Variant<int, float, String> variant = 8; + type = WTF::switchOn(variant, + [](int) { return Type::Int; }, + [](float) { return Type::Float; }, + [](String) { return Type::String; } + ); + EXPECT_TRUE(Type::Int == type); + + + variant = 1.0f; + type = WTF::switchOn(variant, + [](int) { return Type::Int; }, + [](float) { return Type::Float; }, + [](String) { return Type::String; } + ); + EXPECT_TRUE(Type::Float == type); + + + variant = "hello"; + type = WTF::switchOn(variant, + [](int) { return Type::Int; }, + [](float) { return Type::Float; }, + [](String) { return Type::String; } + ); + EXPECT_TRUE(Type::String == type); +} + +TEST(WTF_Variant, ConstructorDestructor) +{ + ConstructorDestructorCounter::TestingScope scope; + + { + auto uniquePtr = std::make_unique<ConstructorDestructorCounter>(); + Variant<std::unique_ptr<ConstructorDestructorCounter>, int> v = WTFMove(uniquePtr); + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(0u, ConstructorDestructorCounter::destructionCount); + } + + EXPECT_EQ(1u, ConstructorDestructorCounter::constructionCount); + EXPECT_EQ(1u, ConstructorDestructorCounter::destructionCount); +} + +TEST(WTF_Variant, RefPtr) +{ + { + RefLogger a("a"); + RefPtr<RefLogger> ref(&a); + Variant<RefPtr<RefLogger>, int> v = ref; + } + + ASSERT_STREQ("ref(a) ref(a) deref(a) deref(a) ", takeLogStr().c_str()); + + { + RefLogger a("a"); + RefPtr<RefLogger> ref(&a); + Variant<RefPtr<RefLogger>, int> v = WTFMove(ref); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +TEST(WTF_Variant, Ref) +{ + { + RefLogger a("a"); + Ref<RefLogger> ref(a); + Variant<Ref<RefLogger>, int> v = WTFMove(ref); + } + + ASSERT_STREQ("ref(a) deref(a) ", takeLogStr().c_str()); +} + +} diff --git a/Tools/TestWebKitAPI/Tests/WTF/Vector.cpp b/Tools/TestWebKitAPI/Tests/WTF/Vector.cpp index 2278784c4..48235b1fc 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/Vector.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/Vector.cpp @@ -27,6 +27,7 @@ #include "MoveOnly.h" #include <wtf/Vector.h> +#include <wtf/text/CString.h> namespace TestWebKitAPI { @@ -34,8 +35,8 @@ TEST(WTF_Vector, Basic) { Vector<int> intVector; EXPECT_TRUE(intVector.isEmpty()); - EXPECT_EQ(0ul, intVector.size()); - EXPECT_EQ(0ul, intVector.capacity()); + EXPECT_EQ(0U, intVector.size()); + EXPECT_EQ(0U, intVector.capacity()); } TEST(WTF_Vector, Iterator) @@ -66,7 +67,7 @@ TEST(WTF_Vector, OverloadedOperatorAmpersand) { struct Test { private: - Test* operator&(); + Test* operator&() = delete; }; Vector<Test> vector; @@ -94,6 +95,103 @@ TEST(WTF_Vector, InitializerList) EXPECT_EQ(4, vector[3]); } +TEST(WTF_Vector, InitializeFromOtherInitialCapacity) +{ + Vector<int, 3> vector = { 1, 3, 2, 4 }; + Vector<int, 5> vectorCopy(vector); + EXPECT_EQ(4U, vector.size()); + EXPECT_EQ(4U, vectorCopy.size()); + EXPECT_EQ(5U, vectorCopy.capacity()); + + EXPECT_EQ(1, vectorCopy[0]); + EXPECT_EQ(3, vectorCopy[1]); + EXPECT_EQ(2, vectorCopy[2]); + EXPECT_EQ(4, vectorCopy[3]); +} + +TEST(WTF_Vector, CopyFromOtherInitialCapacity) +{ + Vector<int, 3> vector = { 1, 3, 2, 4 }; + Vector<int, 5> vectorCopy { 0 }; + EXPECT_EQ(4U, vector.size()); + EXPECT_EQ(1U, vectorCopy.size()); + + vectorCopy = vector; + + EXPECT_EQ(4U, vector.size()); + EXPECT_EQ(4U, vectorCopy.size()); + EXPECT_EQ(5U, vectorCopy.capacity()); + + EXPECT_EQ(1, vectorCopy[0]); + EXPECT_EQ(3, vectorCopy[1]); + EXPECT_EQ(2, vectorCopy[2]); + EXPECT_EQ(4, vectorCopy[3]); +} + +TEST(WTF_Vector, InitializeFromOtherOverflowBehavior) +{ + Vector<int, 7, WTF::CrashOnOverflow> vector = { 4, 3, 2, 1 }; + Vector<int, 7, UnsafeVectorOverflow> vectorCopy(vector); + EXPECT_EQ(4U, vector.size()); + EXPECT_EQ(4U, vectorCopy.size()); + + EXPECT_EQ(4, vectorCopy[0]); + EXPECT_EQ(3, vectorCopy[1]); + EXPECT_EQ(2, vectorCopy[2]); + EXPECT_EQ(1, vectorCopy[3]); +} + +TEST(WTF_Vector, CopyFromOtherOverflowBehavior) +{ + Vector<int, 7, WTF::CrashOnOverflow> vector = { 4, 3, 2, 1 }; + Vector<int, 7, UnsafeVectorOverflow> vectorCopy = { 0, 0, 0 }; + + EXPECT_EQ(4U, vector.size()); + EXPECT_EQ(3U, vectorCopy.size()); + + vectorCopy = vector; + + EXPECT_EQ(4U, vector.size()); + EXPECT_EQ(4U, vectorCopy.size()); + + EXPECT_EQ(4, vectorCopy[0]); + EXPECT_EQ(3, vectorCopy[1]); + EXPECT_EQ(2, vectorCopy[2]); + EXPECT_EQ(1, vectorCopy[3]); +} + +TEST(WTF_Vector, InitializeFromOtherMinCapacity) +{ + Vector<int, 7, WTF::CrashOnOverflow, 1> vector = { 3, 4, 2, 1 }; + Vector<int, 7, WTF::CrashOnOverflow, 50> vectorCopy(vector); + EXPECT_EQ(4U, vector.size()); + EXPECT_EQ(4U, vectorCopy.size()); + + EXPECT_EQ(3, vectorCopy[0]); + EXPECT_EQ(4, vectorCopy[1]); + EXPECT_EQ(2, vectorCopy[2]); + EXPECT_EQ(1, vectorCopy[3]); +} + +TEST(WTF_Vector, CopyFromOtherMinCapacity) +{ + Vector<int, 7, WTF::CrashOnOverflow, 1> vector = { 3, 4, 2, 1 }; + Vector<int, 7, WTF::CrashOnOverflow, 50> vectorCopy; + + EXPECT_EQ(4U, vector.size()); + EXPECT_EQ(0U, vectorCopy.size()); + + vectorCopy = vector; + + EXPECT_EQ(4U, vector.size()); + EXPECT_EQ(4U, vectorCopy.size()); + + EXPECT_EQ(3, vectorCopy[0]); + EXPECT_EQ(4, vectorCopy[1]); + EXPECT_EQ(2, vectorCopy[2]); + EXPECT_EQ(1, vectorCopy[3]); +} + TEST(WTF_Vector, Reverse) { Vector<int> intVector; @@ -149,12 +247,12 @@ TEST(WTF_Vector, MoveOnly_UncheckedAppend) vector.reserveInitialCapacity(100); for (size_t i = 0; i < 100; ++i) { MoveOnly moveOnly(i); - vector.uncheckedAppend(std::move(moveOnly)); - EXPECT_EQ(moveOnly.value(), 0U); + vector.uncheckedAppend(WTFMove(moveOnly)); + EXPECT_EQ(0U, moveOnly.value()); } for (size_t i = 0; i < 100; ++i) - EXPECT_EQ(vector[i].value(), i); + EXPECT_EQ(i, vector[i].value()); } TEST(WTF_Vector, MoveOnly_Append) @@ -163,12 +261,12 @@ TEST(WTF_Vector, MoveOnly_Append) for (size_t i = 0; i < 100; ++i) { MoveOnly moveOnly(i); - vector.append(std::move(moveOnly)); - EXPECT_EQ(moveOnly.value(), 0U); + vector.append(WTFMove(moveOnly)); + EXPECT_EQ(0U, moveOnly.value()); } for (size_t i = 0; i < 100; ++i) - EXPECT_EQ(vector[i].value(), i); + EXPECT_EQ(i, vector[i].value()); for (size_t i = 0; i < 16; ++i) { Vector<MoveOnly> vector; @@ -177,13 +275,13 @@ TEST(WTF_Vector, MoveOnly_Append) for (size_t j = 0; j < i; ++j) vector.append(j); - vector.append(std::move(vector[0])); + vector.append(WTFMove(vector[0])); - EXPECT_EQ(vector[0].value(), 0U); + EXPECT_EQ(0U, vector[0].value()); for (size_t j = 0; j < i; ++j) - EXPECT_EQ(vector[j + 1].value(), j); - EXPECT_EQ(vector.last().value(), i); + EXPECT_EQ(j, vector[j + 1].value()); + EXPECT_EQ(i, vector.last().value()); } } @@ -193,7 +291,7 @@ TEST(WTF_Vector, MoveOnly_Insert) for (size_t i = 0; i < 100; ++i) { MoveOnly moveOnly(i); - vector.insert(0, std::move(moveOnly)); + vector.insert(0, WTFMove(moveOnly)); EXPECT_EQ(0U, moveOnly.value()); } @@ -203,11 +301,11 @@ TEST(WTF_Vector, MoveOnly_Insert) for (size_t i = 0; i < 200; i += 2) { MoveOnly moveOnly(1000 + i); - vector.insert(i, std::move(moveOnly)); + vector.insert(i, WTFMove(moveOnly)); EXPECT_EQ(0U, moveOnly.value()); } - EXPECT_EQ(vector.size(), 200U); + EXPECT_EQ(200U, vector.size()); for (size_t i = 0; i < 200; ++i) { if (i % 2) EXPECT_EQ(99 - i / 2, vector[i].value()); @@ -216,4 +314,304 @@ TEST(WTF_Vector, MoveOnly_Insert) } } +TEST(WTF_Vector, MoveOnly_TakeLast) +{ + Vector<MoveOnly> vector; + + for (size_t i = 0; i < 100; ++i) { + MoveOnly moveOnly(i); + vector.append(WTFMove(moveOnly)); + EXPECT_EQ(0U, moveOnly.value()); + } + + EXPECT_EQ(100U, vector.size()); + for (size_t i = 0; i < 100; ++i) + EXPECT_EQ(99 - i, vector.takeLast().value()); + + EXPECT_EQ(0U, vector.size()); +} + +TEST(WTF_Vector, VectorOfVectorsOfVectorsInlineCapacitySwap) +{ + Vector<Vector<Vector<int, 1>, 1>, 1> a; + Vector<Vector<Vector<int, 1>, 1>, 1> b; + Vector<Vector<Vector<int, 1>, 1>, 1> c; + + EXPECT_EQ(0U, a.size()); + EXPECT_EQ(0U, b.size()); + EXPECT_EQ(0U, c.size()); + + Vector<int, 1> x; + x.append(42); + + EXPECT_EQ(1U, x.size()); + EXPECT_EQ(42, x[0]); + + Vector<Vector<int, 1>, 1> y; + y.append(x); + + EXPECT_EQ(1U, x.size()); + EXPECT_EQ(42, x[0]); + EXPECT_EQ(1U, y.size()); + EXPECT_EQ(1U, y[0].size()); + EXPECT_EQ(42, y[0][0]); + + a.append(y); + + EXPECT_EQ(1U, x.size()); + EXPECT_EQ(42, x[0]); + EXPECT_EQ(1U, y.size()); + EXPECT_EQ(1U, y[0].size()); + EXPECT_EQ(42, y[0][0]); + EXPECT_EQ(1U, a.size()); + EXPECT_EQ(1U, a[0].size()); + EXPECT_EQ(1U, a[0][0].size()); + EXPECT_EQ(42, a[0][0][0]); + + a.swap(b); + + EXPECT_EQ(0U, a.size()); + EXPECT_EQ(1U, x.size()); + EXPECT_EQ(42, x[0]); + EXPECT_EQ(1U, y.size()); + EXPECT_EQ(1U, y[0].size()); + EXPECT_EQ(42, y[0][0]); + EXPECT_EQ(1U, b.size()); + EXPECT_EQ(1U, b[0].size()); + EXPECT_EQ(1U, b[0][0].size()); + EXPECT_EQ(42, b[0][0][0]); + + b.swap(c); + + EXPECT_EQ(0U, a.size()); + EXPECT_EQ(0U, b.size()); + EXPECT_EQ(1U, x.size()); + EXPECT_EQ(42, x[0]); + EXPECT_EQ(1U, y.size()); + EXPECT_EQ(1U, y[0].size()); + EXPECT_EQ(42, y[0][0]); + EXPECT_EQ(1U, c.size()); + EXPECT_EQ(1U, c[0].size()); + EXPECT_EQ(1U, c[0][0].size()); + EXPECT_EQ(42, c[0][0][0]); + + y[0][0] = 24; + + EXPECT_EQ(1U, x.size()); + EXPECT_EQ(42, x[0]); + EXPECT_EQ(1U, y.size()); + EXPECT_EQ(1U, y[0].size()); + EXPECT_EQ(24, y[0][0]); + + a.append(y); + + EXPECT_EQ(1U, x.size()); + EXPECT_EQ(42, x[0]); + EXPECT_EQ(1U, y.size()); + EXPECT_EQ(1U, y[0].size()); + EXPECT_EQ(24, y[0][0]); + EXPECT_EQ(1U, a.size()); + EXPECT_EQ(1U, a[0].size()); + EXPECT_EQ(1U, a[0][0].size()); + EXPECT_EQ(24, a[0][0][0]); + EXPECT_EQ(1U, c.size()); + EXPECT_EQ(1U, c[0].size()); + EXPECT_EQ(1U, c[0][0].size()); + EXPECT_EQ(42, c[0][0][0]); + EXPECT_EQ(0U, b.size()); +} + +TEST(WTF_Vector, RemoveFirst) +{ + Vector<int> v; + EXPECT_TRUE(v.isEmpty()); + EXPECT_FALSE(v.removeFirst(1)); + EXPECT_FALSE(v.removeFirst(-1)); + EXPECT_TRUE(v.isEmpty()); + + v.fill(2, 10); + EXPECT_EQ(10U, v.size()); + EXPECT_FALSE(v.removeFirst(1)); + EXPECT_EQ(10U, v.size()); + v.clear(); + + v.fill(1, 10); + EXPECT_EQ(10U, v.size()); + EXPECT_TRUE(v.removeFirst(1)); + EXPECT_TRUE(v == Vector<int>({1, 1, 1, 1, 1, 1, 1, 1, 1})); + EXPECT_EQ(9U, v.size()); + EXPECT_FALSE(v.removeFirst(2)); + EXPECT_EQ(9U, v.size()); + EXPECT_TRUE(v == Vector<int>({1, 1, 1, 1, 1, 1, 1, 1, 1})); + + unsigned removed = 0; + while (v.removeFirst(1)) + ++removed; + EXPECT_EQ(9U, removed); + EXPECT_TRUE(v.isEmpty()); + + v.resize(1); + EXPECT_EQ(1U, v.size()); + EXPECT_TRUE(v.removeFirst(1)); + EXPECT_EQ(0U, v.size()); + EXPECT_TRUE(v.isEmpty()); +} + +TEST(WTF_Vector, RemoveAll) +{ + // Using a memcpy-able type. + static_assert(VectorTraits<int>::canMoveWithMemcpy, "Should use a memcpy-able type"); + Vector<int> v; + EXPECT_TRUE(v.isEmpty()); + EXPECT_FALSE(v.removeAll(1)); + EXPECT_FALSE(v.removeAll(-1)); + EXPECT_TRUE(v.isEmpty()); + + v.fill(1, 10); + EXPECT_EQ(10U, v.size()); + EXPECT_EQ(10U, v.removeAll(1)); + EXPECT_TRUE(v.isEmpty()); + + v.fill(2, 10); + EXPECT_EQ(10U, v.size()); + EXPECT_EQ(0U, v.removeAll(1)); + EXPECT_EQ(10U, v.size()); + + v = {1, 2, 1, 2, 1, 2, 2, 1, 1, 1}; + EXPECT_EQ(10U, v.size()); + EXPECT_EQ(6U, v.removeAll(1)); + EXPECT_EQ(4U, v.size()); + EXPECT_TRUE(v == Vector<int>({2, 2, 2, 2})); + EXPECT_TRUE(v.find(1) == notFound); + EXPECT_EQ(4U, v.removeAll(2)); + EXPECT_TRUE(v.isEmpty()); + + v = {3, 1, 2, 1, 2, 1, 2, 2, 1, 1, 1, 3}; + EXPECT_EQ(12U, v.size()); + EXPECT_EQ(6U, v.removeAll(1)); + EXPECT_EQ(6U, v.size()); + EXPECT_TRUE(v.find(1) == notFound); + EXPECT_TRUE(v == Vector<int>({3, 2, 2, 2, 2, 3})); + + EXPECT_EQ(4U, v.removeAll(2)); + EXPECT_EQ(2U, v.size()); + EXPECT_TRUE(v.find(2) == notFound); + EXPECT_TRUE(v == Vector<int>({3, 3})); + + EXPECT_EQ(2U, v.removeAll(3)); + EXPECT_TRUE(v.isEmpty()); + + v = {1, 1, 1, 3, 2, 4, 2, 2, 2, 4, 4, 3}; + EXPECT_EQ(12U, v.size()); + EXPECT_EQ(3U, v.removeAll(1)); + EXPECT_EQ(9U, v.size()); + EXPECT_TRUE(v.find(1) == notFound); + EXPECT_TRUE(v == Vector<int>({3, 2, 4, 2, 2, 2, 4, 4, 3})); + + // Using a non memcpy-able type. + static_assert(!VectorTraits<CString>::canMoveWithMemcpy, "Should use a non memcpy-able type"); + Vector<CString> vExpected; + Vector<CString> v2; + EXPECT_TRUE(v2.isEmpty()); + EXPECT_FALSE(v2.removeAll("1")); + EXPECT_TRUE(v2.isEmpty()); + + v2.fill("1", 10); + EXPECT_EQ(10U, v2.size()); + EXPECT_EQ(10U, v2.removeAll("1")); + EXPECT_TRUE(v2.isEmpty()); + + v2.fill("2", 10); + EXPECT_EQ(10U, v2.size()); + EXPECT_EQ(0U, v2.removeAll("1")); + EXPECT_EQ(10U, v2.size()); + + v2 = {"1", "2", "1", "2", "1", "2", "2", "1", "1", "1"}; + EXPECT_EQ(10U, v2.size()); + EXPECT_EQ(6U, v2.removeAll("1")); + EXPECT_EQ(4U, v2.size()); + EXPECT_TRUE(v2.find("1") == notFound); + EXPECT_EQ(4U, v2.removeAll("2")); + EXPECT_TRUE(v2.isEmpty()); + + v2 = {"3", "1", "2", "1", "2", "1", "2", "2", "1", "1", "1", "3"}; + EXPECT_EQ(12U, v2.size()); + EXPECT_EQ(6U, v2.removeAll("1")); + EXPECT_EQ(6U, v2.size()); + EXPECT_TRUE(v2.find("1") == notFound); + vExpected = {"3", "2", "2", "2", "2", "3"}; + EXPECT_TRUE(v2 == vExpected); + + EXPECT_EQ(4U, v2.removeAll("2")); + EXPECT_EQ(2U, v2.size()); + EXPECT_TRUE(v2.find("2") == notFound); + vExpected = {"3", "3"}; + EXPECT_TRUE(v2 == vExpected); + + EXPECT_EQ(2U, v2.removeAll("3")); + EXPECT_TRUE(v2.isEmpty()); + + v2 = {"1", "1", "1", "3", "2", "4", "2", "2", "2", "4", "4", "3"}; + EXPECT_EQ(12U, v2.size()); + EXPECT_EQ(3U, v2.removeAll("1")); + EXPECT_EQ(9U, v2.size()); + EXPECT_TRUE(v2.find("1") == notFound); + vExpected = {"3", "2", "4", "2", "2", "2", "4", "4", "3"}; + EXPECT_TRUE(v2 == vExpected); +} + +TEST(WTF_Vector, RemoveFirstMatching) +{ + Vector<int> v; + EXPECT_TRUE(v.isEmpty()); + EXPECT_FALSE(v.removeFirstMatching([] (int value) { return value > 0; })); + EXPECT_FALSE(v.removeFirstMatching([] (int) { return true; })); + EXPECT_FALSE(v.removeFirstMatching([] (int) { return false; })); + + v = {3, 1, 2, 1, 2, 1, 2, 2, 1, 1, 1, 3}; + EXPECT_EQ(12U, v.size()); + EXPECT_FALSE(v.removeFirstMatching([] (int) { return false; })); + EXPECT_EQ(12U, v.size()); + EXPECT_FALSE(v.removeFirstMatching([] (int value) { return value < 0; })); + EXPECT_EQ(12U, v.size()); + EXPECT_TRUE(v.removeFirstMatching([] (int value) { return value < 3; })); + EXPECT_EQ(11U, v.size()); + EXPECT_TRUE(v == Vector<int>({3, 2, 1, 2, 1, 2, 2, 1, 1, 1, 3})); + EXPECT_TRUE(v.removeFirstMatching([] (int value) { return value > 2; })); + EXPECT_EQ(10U, v.size()); + EXPECT_TRUE(v == Vector<int>({2, 1, 2, 1, 2, 2, 1, 1, 1, 3})); + EXPECT_TRUE(v.removeFirstMatching([] (int value) { return value > 2; })); + EXPECT_EQ(9U, v.size()); + EXPECT_TRUE(v == Vector<int>({2, 1, 2, 1, 2, 2, 1, 1, 1})); +} + +TEST(WTF_Vector, RemoveAllMatching) +{ + Vector<int> v; + EXPECT_TRUE(v.isEmpty()); + EXPECT_FALSE(v.removeAllMatching([] (int value) { return value > 0; })); + EXPECT_FALSE(v.removeAllMatching([] (int) { return true; })); + EXPECT_FALSE(v.removeAllMatching([] (int) { return false; })); + + v = {3, 1, 2, 1, 2, 1, 2, 2, 1, 1, 1, 3}; + EXPECT_EQ(12U, v.size()); + EXPECT_EQ(0U, v.removeAllMatching([] (int) { return false; })); + EXPECT_EQ(12U, v.size()); + EXPECT_EQ(0U, v.removeAllMatching([] (int value) { return value < 0; })); + EXPECT_EQ(12U, v.size()); + EXPECT_EQ(12U, v.removeAllMatching([] (int value) { return value > 0; })); + EXPECT_TRUE(v.isEmpty()); + + v = {3, 1, 2, 1, 2, 1, 3, 2, 2, 1, 1, 1, 3}; + EXPECT_EQ(13U, v.size()); + EXPECT_EQ(3U, v.removeAllMatching([] (int value) { return value > 2; })); + EXPECT_EQ(10U, v.size()); + EXPECT_TRUE(v == Vector<int>({1, 2, 1, 2, 1, 2, 2, 1, 1, 1})); + EXPECT_EQ(6U, v.removeAllMatching([] (int value) { return value != 2; })); + EXPECT_EQ(4U, v.size()); + EXPECT_TRUE(v == Vector<int>({2, 2, 2, 2})); + EXPECT_EQ(4U, v.removeAllMatching([] (int value) { return value == 2; })); + EXPECT_TRUE(v.isEmpty()); +} + } // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp b/Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp new file mode 100644 index 000000000..27649658c --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/WTFString.cpp @@ -0,0 +1,364 @@ +/* + * Copyright (C) 2012 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <limits> +#include <wtf/MathExtras.h> +#include <wtf/text/CString.h> +#include <wtf/text/WTFString.h> + +namespace TestWebKitAPI { + +TEST(WTF, StringCreationFromLiteral) +{ + String stringFromLiteral(ASCIILiteral("Explicit construction syntax")); + ASSERT_EQ(strlen("Explicit construction syntax"), stringFromLiteral.length()); + ASSERT_TRUE(stringFromLiteral == "Explicit construction syntax"); + ASSERT_TRUE(stringFromLiteral.is8Bit()); + ASSERT_TRUE(String("Explicit construction syntax") == stringFromLiteral); + + String stringWithTemplate("Template Literal", String::ConstructFromLiteral); + ASSERT_EQ(strlen("Template Literal"), stringWithTemplate.length()); + ASSERT_TRUE(stringWithTemplate == "Template Literal"); + ASSERT_TRUE(stringWithTemplate.is8Bit()); + ASSERT_TRUE(String("Template Literal") == stringWithTemplate); +} + +TEST(WTF, StringASCII) +{ + CString output; + + // Null String. + output = String().ascii(); + ASSERT_STREQ("", output.data()); + + // Empty String. + output = emptyString().ascii(); + ASSERT_STREQ("", output.data()); + + // Regular String. + output = String(ASCIILiteral("foobar")).ascii(); + ASSERT_STREQ("foobar", output.data()); +} + +static void testNumberToStringECMAScript(double number, const char* reference) +{ + CString numberString = String::numberToStringECMAScript(number).latin1(); + ASSERT_STREQ(reference, numberString.data()); +} + +TEST(WTF, StringNumberToStringECMAScriptBoundaries) +{ + typedef std::numeric_limits<double> Limits; + + // Infinity. + testNumberToStringECMAScript(Limits::infinity(), "Infinity"); + testNumberToStringECMAScript(-Limits::infinity(), "-Infinity"); + + // NaN. + testNumberToStringECMAScript(-Limits::quiet_NaN(), "NaN"); + + // Zeros. + testNumberToStringECMAScript(0, "0"); + testNumberToStringECMAScript(-0, "0"); + + // Min-Max. + testNumberToStringECMAScript(Limits::min(), "2.2250738585072014e-308"); + testNumberToStringECMAScript(Limits::max(), "1.7976931348623157e+308"); +} + +TEST(WTF, StringNumberToStringECMAScriptRegularNumbers) +{ + // Pi. + testNumberToStringECMAScript(piDouble, "3.141592653589793"); + testNumberToStringECMAScript(piFloat, "3.1415927410125732"); + testNumberToStringECMAScript(piOverTwoDouble, "1.5707963267948966"); + testNumberToStringECMAScript(piOverTwoFloat, "1.5707963705062866"); + testNumberToStringECMAScript(piOverFourDouble, "0.7853981633974483"); + testNumberToStringECMAScript(piOverFourFloat, "0.7853981852531433"); + + // e. + const double e = 2.71828182845904523536028747135266249775724709369995; + testNumberToStringECMAScript(e, "2.718281828459045"); + + // c, speed of light in m/s. + const double c = 299792458; + testNumberToStringECMAScript(c, "299792458"); + + // Golen ratio. + const double phi = 1.6180339887498948482; + testNumberToStringECMAScript(phi, "1.618033988749895"); +} + +TEST(WTF, StringReplaceWithLiteral) +{ + // Cases for 8Bit source. + String testString = "1224"; + ASSERT_TRUE(testString.is8Bit()); + testString.replaceWithLiteral('2', ""); + ASSERT_STREQ("14", testString.utf8().data()); + + testString = "1224"; + ASSERT_TRUE(testString.is8Bit()); + testString.replaceWithLiteral('2', "3"); + ASSERT_STREQ("1334", testString.utf8().data()); + + testString = "1224"; + ASSERT_TRUE(testString.is8Bit()); + testString.replaceWithLiteral('2', "555"); + ASSERT_STREQ("15555554", testString.utf8().data()); + + testString = "1224"; + ASSERT_TRUE(testString.is8Bit()); + testString.replaceWithLiteral('3', "NotFound"); + ASSERT_STREQ("1224", testString.utf8().data()); + + // Cases for 16Bit source. + testString = String::fromUTF8("résumé"); + ASSERT_FALSE(testString.is8Bit()); + testString.replaceWithLiteral(UChar(0x00E9 /*U+00E9 is 'é'*/), "e"); + ASSERT_STREQ("resume", testString.utf8().data()); + + testString = String::fromUTF8("résumé"); + ASSERT_FALSE(testString.is8Bit()); + testString.replaceWithLiteral(UChar(0x00E9 /*U+00E9 is 'é'*/), ""); + ASSERT_STREQ("rsum", testString.utf8().data()); + + testString = String::fromUTF8("résumé"); + ASSERT_FALSE(testString.is8Bit()); + testString.replaceWithLiteral('3', "NotFound"); + ASSERT_STREQ("résumé", testString.utf8().data()); +} + +TEST(WTF, StringIsolatedCopy) +{ + String original = "1234"; + auto copy = WTFMove(original).isolatedCopy(); + ASSERT_FALSE(original.impl() == copy.impl()); +} + +TEST(WTF, StringToInt) +{ + bool ok = false; + + EXPECT_EQ(0, String().toInt()); + EXPECT_EQ(0, String().toInt(&ok)); + EXPECT_FALSE(ok); + + EXPECT_EQ(0, emptyString().toInt()); + EXPECT_EQ(0, emptyString().toInt(&ok)); + EXPECT_FALSE(ok); + + EXPECT_EQ(0, String("0").toInt()); + EXPECT_EQ(0, String("0").toInt(&ok)); + EXPECT_TRUE(ok); + + EXPECT_EQ(1, String("1").toInt()); + EXPECT_EQ(1, String("1").toInt(&ok)); + EXPECT_TRUE(ok); + + EXPECT_EQ(2147483647, String("2147483647").toInt()); + EXPECT_EQ(2147483647, String("2147483647").toInt(&ok)); + EXPECT_TRUE(ok); + + EXPECT_EQ(0, String("2147483648").toInt()); + EXPECT_EQ(0, String("2147483648").toInt(&ok)); + EXPECT_FALSE(ok); + + EXPECT_EQ(-2147483648, String("-2147483648").toInt()); + EXPECT_EQ(-2147483648, String("-2147483648").toInt(&ok)); + EXPECT_TRUE(ok); + + EXPECT_EQ(0, String("-2147483649").toInt()); + EXPECT_EQ(0, String("-2147483649").toInt(&ok)); + EXPECT_FALSE(ok); + + // fail if we see leading junk + EXPECT_EQ(0, String("x1").toInt()); + EXPECT_EQ(0, String("x1").toInt(&ok)); + EXPECT_FALSE(ok); + + // succeed if we see leading spaces + EXPECT_EQ(1, String(" 1").toInt()); + EXPECT_EQ(1, String(" 1").toInt(&ok)); + EXPECT_TRUE(ok); + + // silently ignore trailing junk + EXPECT_EQ(1, String("1x").toInt()); + EXPECT_EQ(1, String("1x").toInt(&ok)); + EXPECT_TRUE(ok); +} + +TEST(WTF, StringToDouble) +{ + bool ok = false; + + EXPECT_EQ(0.0, String().toDouble()); + EXPECT_EQ(0.0, String().toDouble(&ok)); + EXPECT_FALSE(ok); + + EXPECT_EQ(0.0, emptyString().toDouble()); + EXPECT_EQ(0.0, emptyString().toDouble(&ok)); + EXPECT_FALSE(ok); + + EXPECT_EQ(0.0, String("0").toDouble()); + EXPECT_EQ(0.0, String("0").toDouble(&ok)); + EXPECT_TRUE(ok); + + EXPECT_EQ(1.0, String("1").toDouble()); + EXPECT_EQ(1.0, String("1").toDouble(&ok)); + EXPECT_TRUE(ok); + + // fail if we see leading junk + EXPECT_EQ(0.0, String("x1").toDouble()); + EXPECT_EQ(0.0, String("x1").toDouble(&ok)); + EXPECT_FALSE(ok); + + // succeed if we see leading spaces + EXPECT_EQ(1.0, String(" 1").toDouble()); + EXPECT_EQ(1.0, String(" 1").toDouble(&ok)); + EXPECT_TRUE(ok); + + // ignore trailing junk, but return false for "ok" + // FIXME: This is an inconsistency with toInt, which always guarantees + // it will return 0 if it's also going to return false for ok. + EXPECT_EQ(1.0, String("1x").toDouble()); + EXPECT_EQ(1.0, String("1x").toDouble(&ok)); + EXPECT_FALSE(ok); + + // parse only numbers, not special values such as "infinity" + EXPECT_EQ(0.0, String("infinity").toDouble()); + EXPECT_EQ(0.0, String("infinity").toDouble(&ok)); + EXPECT_FALSE(ok); + + // parse only numbers, not special values such as "nan" + EXPECT_EQ(0.0, String("nan").toDouble()); + EXPECT_EQ(0.0, String("nan").toDouble(&ok)); + EXPECT_FALSE(ok); +} + +TEST(WTF, StringhasInfixStartingAt) +{ + EXPECT_TRUE(String("Test").is8Bit()); + EXPECT_TRUE(String("Te").is8Bit()); + EXPECT_TRUE(String("st").is8Bit()); + EXPECT_TRUE(String("Test").hasInfixStartingAt(String("Te"), 0)); + EXPECT_FALSE(String("Test").hasInfixStartingAt(String("Te"), 2)); + EXPECT_TRUE(String("Test").hasInfixStartingAt(String("st"), 2)); + EXPECT_FALSE(String("Test").hasInfixStartingAt(String("ST"), 2)); + + EXPECT_FALSE(String::fromUTF8("中国").is8Bit()); + EXPECT_FALSE(String::fromUTF8("中").is8Bit()); + EXPECT_FALSE(String::fromUTF8("国").is8Bit()); + EXPECT_TRUE(String::fromUTF8("中国").hasInfixStartingAt(String::fromUTF8("中"), 0)); + EXPECT_FALSE(String::fromUTF8("中国").hasInfixStartingAt(String::fromUTF8("中"), 1)); + EXPECT_TRUE(String::fromUTF8("中国").hasInfixStartingAt(String::fromUTF8("国"), 1)); + + EXPECT_FALSE(String::fromUTF8("中国").hasInfixStartingAt(String("Te"), 0)); + EXPECT_FALSE(String("Test").hasInfixStartingAt(String::fromUTF8("中"), 2)); +} + +TEST(WTF, StringExistingHash) +{ + String string1("Template Literal"); + ASSERT_FALSE(string1.isNull()); + ASSERT_FALSE(string1.impl()->hasHash()); + string1.impl()->hash(); + ASSERT_EQ(string1.existingHash(), string1.impl()->existingHash()); + String string2; + ASSERT_EQ(string2.existingHash(), 0u); +} + +TEST(WTF, StringUnicodeEqualUCharArray) +{ + String string1("abc"); + ASSERT_FALSE(string1.isNull()); + ASSERT_TRUE(string1.is8Bit()); + UChar ab[] = { 'a', 'b' }; + UChar abc[] = { 'a', 'b', 'c' }; + UChar abcd[] = { 'a', 'b', 'c', 'd' }; + UChar aBc[] = { 'a', 'B', 'c' }; + ASSERT_FALSE(equal(string1, ab)); + ASSERT_TRUE(equal(string1, abc)); + ASSERT_FALSE(equal(string1, abcd)); + ASSERT_FALSE(equal(string1, aBc)); + + String string2(abc, 3); + ASSERT_FALSE(equal(string2, ab)); + ASSERT_TRUE(equal(string2, abc)); + ASSERT_FALSE(equal(string2, abcd)); + ASSERT_FALSE(equal(string2, aBc)); +} + +TEST(WTF, StringRightBasic) +{ + auto reference = String::fromUTF8("Cappuccino"); + EXPECT_TRUE(reference.right(0) == String::fromUTF8("")); + EXPECT_TRUE(reference.right(1) == String::fromUTF8("o")); + EXPECT_TRUE(reference.right(2) == String::fromUTF8("no")); + EXPECT_TRUE(reference.right(3) == String::fromUTF8("ino")); + EXPECT_TRUE(reference.right(4) == String::fromUTF8("cino")); + EXPECT_TRUE(reference.right(5) == String::fromUTF8("ccino")); + EXPECT_TRUE(reference.right(6) == String::fromUTF8("uccino")); + EXPECT_TRUE(reference.right(7) == String::fromUTF8("puccino")); + EXPECT_TRUE(reference.right(8) == String::fromUTF8("ppuccino")); + EXPECT_TRUE(reference.right(9) == String::fromUTF8("appuccino")); + EXPECT_TRUE(reference.right(10) == String::fromUTF8("Cappuccino")); +} + +TEST(WTF, StringLeftBasic) +{ + auto reference = String::fromUTF8("Cappuccino"); + EXPECT_TRUE(reference.left(0) == String::fromUTF8("")); + EXPECT_TRUE(reference.left(1) == String::fromUTF8("C")); + EXPECT_TRUE(reference.left(2) == String::fromUTF8("Ca")); + EXPECT_TRUE(reference.left(3) == String::fromUTF8("Cap")); + EXPECT_TRUE(reference.left(4) == String::fromUTF8("Capp")); + EXPECT_TRUE(reference.left(5) == String::fromUTF8("Cappu")); + EXPECT_TRUE(reference.left(6) == String::fromUTF8("Cappuc")); + EXPECT_TRUE(reference.left(7) == String::fromUTF8("Cappucc")); + EXPECT_TRUE(reference.left(8) == String::fromUTF8("Cappucci")); + EXPECT_TRUE(reference.left(9) == String::fromUTF8("Cappuccin")); + EXPECT_TRUE(reference.left(10) == String::fromUTF8("Cappuccino")); +} + +TEST(WTF, StringReverseFindBasic) +{ + auto reference = String::fromUTF8("Cappuccino"); + EXPECT_EQ(reference.reverseFind('o'), 9U); + EXPECT_EQ(reference.reverseFind('n'), 8U); + EXPECT_EQ(reference.reverseFind('c'), 6U); + EXPECT_EQ(reference.reverseFind('p'), 3U); + EXPECT_EQ(reference.reverseFind('k'), notFound); + + EXPECT_EQ(reference.reverseFind('o', 8), notFound); + EXPECT_EQ(reference.reverseFind('c', 8), 6U); + EXPECT_EQ(reference.reverseFind('c', 6), 6U); + EXPECT_EQ(reference.reverseFind('c', 5), 5U); + EXPECT_EQ(reference.reverseFind('c', 4), notFound); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp b/Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp new file mode 100644 index 000000000..745aadd2b --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/WeakPtr.cpp @@ -0,0 +1,193 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "Test.h" +#include <wtf/WeakPtr.h> + +namespace TestWebKitAPI { + +TEST(WTF_WeakPtr, Basic) +{ + int dummy = 5; + WeakPtrFactory<int>* factory = new WeakPtrFactory<int>(&dummy); + WeakPtr<int> weakPtr1 = factory->createWeakPtr(); + WeakPtr<int> weakPtr2 = factory->createWeakPtr(); + WeakPtr<int> weakPtr3 = factory->createWeakPtr(); + EXPECT_EQ(weakPtr1.get(), &dummy); + EXPECT_EQ(weakPtr2.get(), &dummy); + EXPECT_EQ(weakPtr3.get(), &dummy); + EXPECT_TRUE(weakPtr1); + EXPECT_TRUE(weakPtr2); + EXPECT_TRUE(weakPtr3); + EXPECT_TRUE(weakPtr1 == weakPtr2); + EXPECT_TRUE(weakPtr1 == &dummy); + EXPECT_TRUE(&dummy == weakPtr2); + delete factory; + EXPECT_NULL(weakPtr1.get()); + EXPECT_NULL(weakPtr2.get()); + EXPECT_NULL(weakPtr3.get()); + EXPECT_FALSE(weakPtr1); + EXPECT_FALSE(weakPtr2); + EXPECT_FALSE(weakPtr3); +} + +TEST(WTF_WeakPtr, Assignment) +{ + int dummy = 5; + WeakPtr<int> weakPtr; + { + WeakPtrFactory<int> factory(&dummy); + EXPECT_NULL(weakPtr.get()); + weakPtr = factory.createWeakPtr(); + EXPECT_EQ(weakPtr.get(), &dummy); + } + EXPECT_NULL(weakPtr.get()); +} + +TEST(WTF_WeakPtr, MultipleFactories) +{ + int dummy1 = 5; + int dummy2 = 7; + WeakPtrFactory<int>* factory1 = new WeakPtrFactory<int>(&dummy1); + WeakPtrFactory<int>* factory2 = new WeakPtrFactory<int>(&dummy2); + WeakPtr<int> weakPtr1 = factory1->createWeakPtr(); + WeakPtr<int> weakPtr2 = factory2->createWeakPtr(); + EXPECT_EQ(weakPtr1.get(), &dummy1); + EXPECT_EQ(weakPtr2.get(), &dummy2); + EXPECT_TRUE(weakPtr1 != weakPtr2); + EXPECT_TRUE(weakPtr1 != &dummy2); + EXPECT_TRUE(&dummy1 != weakPtr2); + delete factory1; + EXPECT_NULL(weakPtr1.get()); + EXPECT_EQ(weakPtr2.get(), &dummy2); + delete factory2; + EXPECT_NULL(weakPtr2.get()); +} + +TEST(WTF_WeakPtr, RevokeAll) +{ + int dummy = 5; + WeakPtrFactory<int> factory(&dummy); + WeakPtr<int> weakPtr1 = factory.createWeakPtr(); + WeakPtr<int> weakPtr2 = factory.createWeakPtr(); + WeakPtr<int> weakPtr3 = factory.createWeakPtr(); + EXPECT_EQ(weakPtr1.get(), &dummy); + EXPECT_EQ(weakPtr2.get(), &dummy); + EXPECT_EQ(weakPtr3.get(), &dummy); + factory.revokeAll(); + EXPECT_NULL(weakPtr1.get()); + EXPECT_NULL(weakPtr2.get()); + EXPECT_NULL(weakPtr3.get()); +} + +TEST(WTF_WeakPtr, NullFactory) +{ + WeakPtrFactory<int> factory(nullptr); + WeakPtr<int> weakPtr = factory.createWeakPtr(); + EXPECT_NULL(weakPtr.get()); + factory.revokeAll(); + EXPECT_NULL(weakPtr.get()); +} + +struct Foo { + void bar() { }; +}; + +TEST(WTF_WeakPtr, Dereference) +{ + Foo f; + WeakPtrFactory<Foo> factory(&f); + WeakPtr<Foo> weakPtr = factory.createWeakPtr(); + weakPtr->bar(); +} + +TEST(WTF_WeakPtr, Forget) +{ + int dummy = 5; + int dummy2 = 7; + + WeakPtrFactory<int> outerFactory(&dummy2); + WeakPtr<int> weakPtr1, weakPtr2, weakPtr3, weakPtr4; + { + WeakPtrFactory<int> innerFactory(&dummy); + weakPtr1 = innerFactory.createWeakPtr(); + weakPtr2 = innerFactory.createWeakPtr(); + weakPtr3 = innerFactory.createWeakPtr(); + EXPECT_EQ(weakPtr1.get(), &dummy); + EXPECT_EQ(weakPtr2.get(), &dummy); + EXPECT_EQ(weakPtr3.get(), &dummy); + weakPtr1.clear(); + weakPtr3 = nullptr; + EXPECT_NULL(weakPtr1.get()); + EXPECT_EQ(weakPtr2.get(), &dummy); + EXPECT_NULL(weakPtr3.get()); + weakPtr1.clear(); + weakPtr3.clear(); + EXPECT_NULL(weakPtr1.get()); + EXPECT_EQ(weakPtr2.get(), &dummy); + EXPECT_NULL(weakPtr3.get()); + weakPtr3 = nullptr; + EXPECT_NULL(weakPtr1.get()); + EXPECT_EQ(weakPtr2.get(), &dummy); + EXPECT_NULL(weakPtr3.get()); + + weakPtr4 = weakPtr2; + EXPECT_EQ(weakPtr2.get(), &dummy); + EXPECT_EQ(weakPtr4.get(), &dummy); + + WeakPtr<int> weakPtr5 = weakPtr2; + EXPECT_EQ(weakPtr2.get(), &dummy); + EXPECT_EQ(weakPtr5.get(), &dummy); + weakPtr5.clear(); + EXPECT_NULL(weakPtr5.get()); + EXPECT_EQ(weakPtr2.get(), &dummy); + + weakPtr4 = outerFactory.createWeakPtr(); + EXPECT_EQ(weakPtr2.get(), &dummy); + EXPECT_EQ(weakPtr4.get(), &dummy2); + } + + EXPECT_NULL(weakPtr1.get()); + EXPECT_NULL(weakPtr2.get()); + EXPECT_EQ(weakPtr4.get(), &dummy2); + + WeakPtr<int> weakPtr5 = weakPtr4; + EXPECT_EQ(weakPtr4.get(), &dummy2); + EXPECT_EQ(weakPtr5.get(), &dummy2); + weakPtr5.clear(); + EXPECT_NULL(weakPtr5.get()); + WeakPtr<int> weakPtr6 = weakPtr5; + EXPECT_NULL(weakPtr6.get()); + EXPECT_EQ(weakPtr5.get(), weakPtr6.get()); + + WeakPtr<int> weakPtr7 = outerFactory.createWeakPtr(); + EXPECT_EQ(weakPtr7.get(), &dummy2); + weakPtr7 = nullptr; + EXPECT_NULL(weakPtr7.get()); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/WorkQueue.cpp b/Tools/TestWebKitAPI/Tests/WTF/WorkQueue.cpp new file mode 100644 index 000000000..7e277e94c --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/WorkQueue.cpp @@ -0,0 +1,236 @@ +/* + * Copyright (C) 2015 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "Test.h" +#include <wtf/Condition.h> +#include <wtf/Lock.h> +#include <wtf/Vector.h> +#include <wtf/WorkQueue.h> +#include <string> +#include <thread> + +namespace TestWebKitAPI { + +static const char* simpleTestLabel = "simpleTest"; +static const char* longTestLabel = "longTest"; +static const char* thirdTestLabel = "thirdTest"; +static const char* dispatchAfterLabel = "dispatchAfter"; + +TEST(WTF_WorkQueue, Simple) +{ + Lock m_lock; + Condition m_testCompleted; + Vector<std::string> m_functionCallOrder; + + bool calledSimpleTest = false; + bool calledLongTest = false; + bool calledThirdTest = false; + + static const char* simpleTestLabel = "simpleTest"; + static const char* longTestLabel = "longTest"; + static const char* thirdTestLabel = "thirdTest"; + + auto queue = WorkQueue::create("com.apple.WebKit.Test.simple"); + int initialRefCount = queue->refCount(); + EXPECT_EQ(1, initialRefCount); + + LockHolder locker(m_lock); + queue->dispatch([&](void) { + m_functionCallOrder.append(simpleTestLabel); + calledSimpleTest = true; + }); + + queue->dispatch([&](void) { + m_functionCallOrder.append(longTestLabel); + std::this_thread::sleep_for(std::chrono::nanoseconds(100)); + calledLongTest = true; + }); + + queue->dispatch([&](void) { + LockHolder locker(m_lock); + m_functionCallOrder.append(thirdTestLabel); + calledThirdTest = true; + + EXPECT_TRUE(calledSimpleTest); + EXPECT_TRUE(calledLongTest); + EXPECT_TRUE(calledThirdTest); + + m_testCompleted.notifyOne(); + }); + + EXPECT_GT(queue->refCount(), 1); + + m_testCompleted.wait(m_lock); + + EXPECT_TRUE(calledSimpleTest); + EXPECT_TRUE(calledLongTest); + EXPECT_TRUE(calledThirdTest); + + EXPECT_EQ(static_cast<size_t>(3), m_functionCallOrder.size()); + EXPECT_STREQ(simpleTestLabel, m_functionCallOrder[0].c_str()); + EXPECT_STREQ(longTestLabel, m_functionCallOrder[1].c_str()); + EXPECT_STREQ(thirdTestLabel, m_functionCallOrder[2].c_str()); +} + +TEST(WTF_WorkQueue, TwoQueues) +{ + Lock m_lock; + Condition m_testQueue1Completed, m_testQueue2Completed; + Vector<std::string> m_functionCallOrder; + + bool calledSimpleTest = false; + bool calledLongTest = false; + bool calledThirdTest = false; + + auto queue1 = WorkQueue::create("com.apple.WebKit.Test.twoQueues1"); + auto queue2 = WorkQueue::create("com.apple.WebKit.Test.twoQueues2"); + + EXPECT_EQ(1, queue1->refCount()); + EXPECT_EQ(1, queue2->refCount()); + + LockHolder locker(m_lock); + + queue1->dispatch([&](void) { + m_functionCallOrder.append(simpleTestLabel); + calledSimpleTest = true; + }); + + queue2->dispatch([&](void) { + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + + LockHolder locker(m_lock); + + // Will fail if queue2 took the mutex before queue1. + EXPECT_TRUE(calledThirdTest); + + m_functionCallOrder.append(longTestLabel); + calledLongTest = true; + m_testQueue2Completed.notifyOne(); + }); + + queue1->dispatch([&](void) { + LockHolder locker(m_lock); + m_functionCallOrder.append(thirdTestLabel); + calledThirdTest = true; + + m_testQueue1Completed.notifyOne(); + }); + + m_testQueue1Completed.wait(m_lock); + + EXPECT_TRUE(calledSimpleTest); + EXPECT_FALSE(calledLongTest); + EXPECT_TRUE(calledThirdTest); + + m_testQueue2Completed.wait(m_lock); + + EXPECT_TRUE(calledSimpleTest); + EXPECT_TRUE(calledLongTest); + EXPECT_TRUE(calledThirdTest); + + EXPECT_EQ(static_cast<size_t>(3), m_functionCallOrder.size()); + EXPECT_STREQ(simpleTestLabel, m_functionCallOrder[0].c_str()); + EXPECT_STREQ(thirdTestLabel, m_functionCallOrder[1].c_str()); + EXPECT_STREQ(longTestLabel, m_functionCallOrder[2].c_str()); +} + +TEST(WTF_WorkQueue, DispatchAfter) +{ + Lock m_lock; + Condition m_testCompleted, m_dispatchAfterTestCompleted; + Vector<std::string> m_functionCallOrder; + + bool calledSimpleTest = false; + bool calledDispatchAfterTest = false; + + auto queue = WorkQueue::create("com.apple.WebKit.Test.dispatchAfter"); + + LockHolder locker(m_lock); + + queue->dispatch([&](void) { + LockHolder locker(m_lock); + m_functionCallOrder.append(simpleTestLabel); + calledSimpleTest = true; + m_testCompleted.notifyOne(); + }); + + queue->dispatchAfter(std::chrono::milliseconds(500), [&](void) { + LockHolder locker(m_lock); + m_functionCallOrder.append(dispatchAfterLabel); + calledDispatchAfterTest = true; + m_dispatchAfterTestCompleted.notifyOne(); + }); + + m_testCompleted.wait(m_lock); + + EXPECT_TRUE(calledSimpleTest); + EXPECT_FALSE(calledDispatchAfterTest); + + m_dispatchAfterTestCompleted.wait(m_lock); + + EXPECT_TRUE(calledSimpleTest); + EXPECT_TRUE(calledDispatchAfterTest); + + EXPECT_EQ(static_cast<size_t>(2), m_functionCallOrder.size()); + EXPECT_STREQ(simpleTestLabel, m_functionCallOrder[0].c_str()); + EXPECT_STREQ(dispatchAfterLabel, m_functionCallOrder[1].c_str()); +} + +TEST(WTF_WorkQueue, DestroyOnSelf) +{ + Lock lock; + Condition dispatchAfterTestStarted; + Condition dispatchAfterTestCompleted; + bool started = false; + bool completed = false; + + { + LockHolder locker(lock); + { + auto queue = WorkQueue::create("com.apple.WebKit.Test.dispatchAfter"); + queue->dispatchAfter(std::chrono::milliseconds(500), [&](void) { + LockHolder locker(lock); + dispatchAfterTestStarted.wait(lock, [&] { + return started; + }); + completed = true; + dispatchAfterTestCompleted.notifyOne(); + }); + } + started = true; + dispatchAfterTestStarted.notifyOne(); + } + { + LockHolder locker(lock); + dispatchAfterTestCompleted.wait(lock, [&] { + return completed; + }); + WTF::sleep(0.1); + } +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/darwin/OSObjectPtr.cpp b/Tools/TestWebKitAPI/Tests/WTF/darwin/OSObjectPtr.cpp new file mode 100644 index 000000000..5389dcbc8 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/darwin/OSObjectPtr.cpp @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2014 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <wtf/OSObjectPtr.h> + +#include <dispatch/dispatch.h> +#include <CoreFoundation/CoreFoundation.h> + +namespace TestWebKitAPI { + +TEST(OSObjectPtr, AdoptOSObject) +{ + OSObjectPtr<dispatch_queue_t> foo = adoptOSObject(dispatch_queue_create(0, DISPATCH_QUEUE_SERIAL)); + + EXPECT_EQ(1, CFGetRetainCount(foo.get())); +} + +TEST(OSObjectPtr, RetainRelease) +{ + dispatch_queue_t foo = dispatch_queue_create(0, DISPATCH_QUEUE_SERIAL); + EXPECT_EQ(1, CFGetRetainCount(foo)); + + WTF::retainOSObject(foo); + EXPECT_EQ(2, CFGetRetainCount(foo)); + + WTF::releaseOSObject(foo); + EXPECT_EQ(1, CFGetRetainCount(foo)); +} + +TEST(OSObjectPtr, LeakRef) +{ + OSObjectPtr<dispatch_queue_t> foo = adoptOSObject(dispatch_queue_create(0, DISPATCH_QUEUE_SERIAL)); + EXPECT_EQ(1, CFGetRetainCount(foo.get())); + + dispatch_queue_t queue = foo.leakRef(); + EXPECT_EQ(nullptr, foo.get()); + EXPECT_EQ(1, CFGetRetainCount(queue)); + + WTF::releaseOSObject(queue); +} + +} // namespace TestWebKitAPI diff --git a/Tools/TestWebKitAPI/Tests/WTF/gobject/GUniquePtr.cpp b/Tools/TestWebKitAPI/Tests/WTF/glib/GUniquePtr.cpp index 8942f8657..11f02c7b0 100644 --- a/Tools/TestWebKitAPI/Tests/WTF/gobject/GUniquePtr.cpp +++ b/Tools/TestWebKitAPI/Tests/WTF/glib/GUniquePtr.cpp @@ -80,7 +80,7 @@ static void (* _g_key_file_free)(GKeyFile*) = g_key_file_free; log() << "g_key_file_free(" << ptr << ");"; \ _g_key_file_free(x); -#include <wtf/gobject/GUniquePtr.h> +#include <wtf/glib/GUniquePtr.h> namespace TestWebKitAPI { diff --git a/Tools/TestWebKitAPI/Tests/WTF/glib/WorkQueueGLib.cpp b/Tools/TestWebKitAPI/Tests/WTF/glib/WorkQueueGLib.cpp new file mode 100644 index 000000000..9923d6580 --- /dev/null +++ b/Tools/TestWebKitAPI/Tests/WTF/glib/WorkQueueGLib.cpp @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2015 Igalia S.L. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "Test.h" +#include <gio/gio.h> +#include <thread> +#include <wtf/Condition.h> +#include <wtf/Lock.h> +#include <wtf/WorkQueue.h> +#include <wtf/glib/GRefPtr.h> +#include <wtf/glib/GUniquePtr.h> + +namespace TestWebKitAPI { + +TEST(WTF_WorkQueue, AsyncIO) +{ + struct TestingContext { + Lock m_lock; + Condition m_testCompleted; + GMainContext* m_mainContext; + } context; + + auto queue = WorkQueue::create("com.apple.WebKit.Test.AsyncIO"); + context.m_mainContext = g_main_context_default(); + EXPECT_FALSE(g_main_context_get_thread_default()); + + GUniquePtr<char> currentDirectory(g_get_current_dir()); + GRefPtr<GFile> file = adoptGRef(g_file_new_for_path(currentDirectory.get())); + + LockHolder locker(context.m_lock); + queue->dispatch([&](void) { + EXPECT_TRUE(g_main_context_get_thread_default()); + EXPECT_TRUE(g_main_context_get_thread_default() != context.m_mainContext); + context.m_mainContext = g_main_context_get_thread_default(); + g_file_query_info_async(file.get(), G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, nullptr, + [](GObject*, GAsyncResult*, gpointer userData) { + TestingContext* context = static_cast<TestingContext*>(userData); + LockHolder locker(context->m_lock); + EXPECT_EQ(g_main_context_get_thread_default(), context->m_mainContext); + context->m_testCompleted.notifyOne(); + }, &context); + }); + + context.m_testCompleted.wait(context.m_lock); +} + +} // namespace TestWebKitAPI |