Tools/TestWebKitAPI/Tests/WTF/WorkQueue.cpp - WebKit - Git at Google

 /*
  * 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 <memory>
 #include <string>
 #include <thread>

 namespace TestWebKitAPI {

 using namespace std::literals::chrono_literals;

 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);

     Locker locker { m_lock };
     queue->dispatch([&](void) {
         m_functionCallOrder.append(simpleTestLabel);
         calledSimpleTest = true;
     });

     queue->dispatch([&](void) {
         m_functionCallOrder.append(longTestLabel);
         std::this_thread::sleep_for(100ns);
         calledLongTest = true;
     });

     queue->dispatch([&](void) {
         Locker 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(), 1U);

     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(1U, queue1->refCount());
     EXPECT_EQ(1U, queue2->refCount());

     Locker locker { m_lock };

     queue1->dispatch([&](void) {
         m_functionCallOrder.append(simpleTestLabel);
         calledSimpleTest = true;
     });

     queue2->dispatch([&](void) {
         std::this_thread::sleep_for(50ms);

         Locker 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) {
         Locker 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");

     Locker locker { m_lock };

     queue->dispatch([&](void) {
         Locker locker { m_lock };
         m_functionCallOrder.append(simpleTestLabel);
         calledSimpleTest = true;
         m_testCompleted.notifyOne();
     });

     queue->dispatchAfter(500_ms, [&](void) {
         Locker 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;

     {
         Locker locker { lock };
         {
             auto queue = WorkQueue::create("com.apple.WebKit.Test.dispatchAfter");
             queue->dispatchAfter(500_ms, [&](void) {
                 Locker locker { lock };
                 dispatchAfterTestStarted.wait(lock, [&] {
                     return started;
                 });
                 completed = true;
                 dispatchAfterTestCompleted.notifyOne();
             });
         }
         started = true;
         dispatchAfterTestStarted.notifyOne();
     }
     {
         Locker locker { lock };
         dispatchAfterTestCompleted.wait(lock, [&] {
             return completed;
         });
         WTF::sleep(100_ms);
     }
 }

 TEST(WTF_WorkQueue, DispatchSync)
 {
     auto queue = WorkQueue::create("com.apple.WebKit.Test.dispatchSync");
     std::atomic<bool> firstAsyncTaskRan = false;
     std::atomic<bool> secondAsyncTaskRan = false;
     std::atomic<bool> firstSyncTaskTaskRan = false;
     std::atomic<bool> secondSyncTaskTaskRan = false;
     queue->dispatch([&] {
         EXPECT_FALSE(firstAsyncTaskRan);
         EXPECT_FALSE(firstSyncTaskTaskRan);
         EXPECT_FALSE(secondAsyncTaskRan);
         EXPECT_FALSE(secondSyncTaskTaskRan);
         firstAsyncTaskRan = true;
     });
     queue->dispatchSync([&] {
         EXPECT_TRUE(firstAsyncTaskRan);
         EXPECT_FALSE(firstSyncTaskTaskRan);
         EXPECT_FALSE(secondAsyncTaskRan);
         EXPECT_FALSE(secondSyncTaskTaskRan);
         firstSyncTaskTaskRan = true;
     });
     EXPECT_TRUE(firstSyncTaskTaskRan);
     queue->dispatch([&] {
         EXPECT_TRUE(firstAsyncTaskRan);
         EXPECT_TRUE(firstSyncTaskTaskRan);
         EXPECT_FALSE(secondAsyncTaskRan);
         EXPECT_FALSE(secondSyncTaskTaskRan);
         secondAsyncTaskRan = true;
     });
     queue->dispatchSync([&] {
         EXPECT_TRUE(firstAsyncTaskRan);
         EXPECT_TRUE(firstSyncTaskTaskRan);
         EXPECT_TRUE(secondAsyncTaskRan);
         EXPECT_FALSE(secondSyncTaskTaskRan);
         secondSyncTaskTaskRan = true;
     });
     EXPECT_TRUE(secondSyncTaskTaskRan);
 }

 // Tests that the Function passed to WorkQueue::dispatch is destructed on the thread that
 // runs the Function. It is a common pattern to capture a owning reference into a Function
 // and dispatch that to a queue to ensure ordering (or thread affinity) of the object destruction.
 TEST(WTF_WorkQueue, DestroyDispatchedOnDispatchQueue)
 {
     std::atomic<size_t> counter = 0;
     class DestructionWorkQueueTester {
     public:
         DestructionWorkQueueTester(std::atomic<size_t>& counter)
             : m_counter(counter)
         {
         }
         ~DestructionWorkQueueTester()
         {
             EXPECT_NE(m_createdInThread, Thread::current().uid());
             m_counter++;
         }
     private:
         uint32_t m_createdInThread = Thread::current().uid();
         std::atomic<size_t>& m_counter;
     };
     constexpr size_t queueCount = 50;
     constexpr size_t iterationCount = 10000;
     RefPtr<WorkQueue> queue[queueCount];
     for (size_t i = 0; i < queueCount; ++i)
         queue[i] = WorkQueue::create("com.apple.WebKit.Test.destroyDispatchedOnDispatchQueue", WorkQueue::QOS::UserInteractive);

     for (size_t i = 0; i < iterationCount; ++i) {
         for (size_t j = 0; j < queueCount; ++j)
             queue[j]->dispatch([instance = std::make_unique<DestructionWorkQueueTester>(counter)]() { }); // NOLINT
     }
     for (size_t j = 0; j < queueCount; ++j)
         queue[j]->dispatchSync([] { });
     EXPECT_EQ(queueCount * iterationCount, counter);
 }

 namespace {
 struct AssertionTestHolder {
     const RefPtr<WorkQueue> queue { WorkQueue::create("com.apple.WebKit.Test.ThreadSafetyAnalysisAssertIsCurrentWorks", WorkQueue::QOS::UserInteractive) };
     size_t counter WTF_GUARDED_BY_CAPABILITY(*queue) { 0 };
     size_t result { 0 }; // This is here to support the result assertion. The compiler doesn't allow us to obtain the `counter` otherwise.

     void testTask()
     {
         assertIsCurrent(*queue); // This is being tested.
         ++counter;
     }
     void computeResult() WTF_REQUIRES_CAPABILITY(*queue) // This is being tested.
     {
         result = ++counter;
     }
     template<typename T> void testTaskThatFailsToCompile()
     {
         ++counter;
     }
 };
 }

 TEST(WTF_WorkQueue, ThreadSafetyAnalysisAssertIsCurrentWorks)
 {
     constexpr size_t queueCount = 50;
     constexpr size_t iterationCount = 10000;

     AssertionTestHolder holders[queueCount];
     for (size_t i = 0; i < iterationCount; ++i) {
         for (auto& holder : holders)
             holder.queue->dispatch([&holder] { holder.testTask(); });
     }
 // #define TEST_COMPILE_FAILURE
 #ifdef TEST_COMPILE_FAILURE
     for (auto& holder : holders)
         holder.queue->dispatchSync([&holder] { holder.testTaskThatFailsToCompile<int>(); });
 #endif
     for (auto& holder : holders)
         holder.queue->dispatchSync([&holder] { assertIsCurrent(*holder.queue); holder.computeResult(); });
     for (auto& holder : holders)
         EXPECT_EQ(iterationCount + 1, holder.result);
 }

 } // namespace TestWebKitAPI
	/*
	* 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 <memory>
	#include <string>
	#include <thread>

	namespace TestWebKitAPI {

	using namespace std::literals::chrono_literals;

	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);

	Locker locker { m_lock };
	queue->dispatch([&](void) {
	m_functionCallOrder.append(simpleTestLabel);
	calledSimpleTest = true;
	});

	queue->dispatch([&](void) {
	m_functionCallOrder.append(longTestLabel);
	std::this_thread::sleep_for(100ns);
	calledLongTest = true;
	});

	queue->dispatch([&](void) {
	Locker 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(), 1U);

	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(1U, queue1->refCount());
	EXPECT_EQ(1U, queue2->refCount());

	Locker locker { m_lock };

	queue1->dispatch([&](void) {
	m_functionCallOrder.append(simpleTestLabel);
	calledSimpleTest = true;
	});

	queue2->dispatch([&](void) {
	std::this_thread::sleep_for(50ms);

	Locker 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) {
	Locker 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");

	Locker locker { m_lock };

	queue->dispatch([&](void) {
	Locker locker { m_lock };
	m_functionCallOrder.append(simpleTestLabel);
	calledSimpleTest = true;
	m_testCompleted.notifyOne();
	});

	queue->dispatchAfter(500_ms, [&](void) {
	Locker 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;

	{
	Locker locker { lock };
	{
	auto queue = WorkQueue::create("com.apple.WebKit.Test.dispatchAfter");
	queue->dispatchAfter(500_ms, [&](void) {
	Locker locker { lock };
	dispatchAfterTestStarted.wait(lock, [&] {
	return started;
	});
	completed = true;
	dispatchAfterTestCompleted.notifyOne();
	});
	}
	started = true;
	dispatchAfterTestStarted.notifyOne();
	}
	{
	Locker locker { lock };
	dispatchAfterTestCompleted.wait(lock, [&] {
	return completed;
	});
	WTF::sleep(100_ms);
	}
	}

	TEST(WTF_WorkQueue, DispatchSync)
	{
	auto queue = WorkQueue::create("com.apple.WebKit.Test.dispatchSync");
	std::atomic<bool> firstAsyncTaskRan = false;
	std::atomic<bool> secondAsyncTaskRan = false;
	std::atomic<bool> firstSyncTaskTaskRan = false;
	std::atomic<bool> secondSyncTaskTaskRan = false;
	queue->dispatch([&] {
	EXPECT_FALSE(firstAsyncTaskRan);
	EXPECT_FALSE(firstSyncTaskTaskRan);
	EXPECT_FALSE(secondAsyncTaskRan);
	EXPECT_FALSE(secondSyncTaskTaskRan);
	firstAsyncTaskRan = true;
	});
	queue->dispatchSync([&] {
	EXPECT_TRUE(firstAsyncTaskRan);
	EXPECT_FALSE(firstSyncTaskTaskRan);
	EXPECT_FALSE(secondAsyncTaskRan);
	EXPECT_FALSE(secondSyncTaskTaskRan);
	firstSyncTaskTaskRan = true;
	});
	EXPECT_TRUE(firstSyncTaskTaskRan);
	queue->dispatch([&] {
	EXPECT_TRUE(firstAsyncTaskRan);
	EXPECT_TRUE(firstSyncTaskTaskRan);
	EXPECT_FALSE(secondAsyncTaskRan);
	EXPECT_FALSE(secondSyncTaskTaskRan);
	secondAsyncTaskRan = true;
	});
	queue->dispatchSync([&] {
	EXPECT_TRUE(firstAsyncTaskRan);
	EXPECT_TRUE(firstSyncTaskTaskRan);
	EXPECT_TRUE(secondAsyncTaskRan);
	EXPECT_FALSE(secondSyncTaskTaskRan);
	secondSyncTaskTaskRan = true;
	});
	EXPECT_TRUE(secondSyncTaskTaskRan);
	}

	// Tests that the Function passed to WorkQueue::dispatch is destructed on the thread that
	// runs the Function. It is a common pattern to capture a owning reference into a Function
	// and dispatch that to a queue to ensure ordering (or thread affinity) of the object destruction.
	TEST(WTF_WorkQueue, DestroyDispatchedOnDispatchQueue)
	{
	std::atomic<size_t> counter = 0;
	class DestructionWorkQueueTester {
	public:
	DestructionWorkQueueTester(std::atomic<size_t>& counter)
	: m_counter(counter)
	{
	}
	~DestructionWorkQueueTester()
	{
	EXPECT_NE(m_createdInThread, Thread::current().uid());
	m_counter++;
	}
	private:
	uint32_t m_createdInThread = Thread::current().uid();
	std::atomic<size_t>& m_counter;
	};
	constexpr size_t queueCount = 50;
	constexpr size_t iterationCount = 10000;
	RefPtr<WorkQueue> queue[queueCount];
	for (size_t i = 0; i < queueCount; ++i)
	queue[i] = WorkQueue::create("com.apple.WebKit.Test.destroyDispatchedOnDispatchQueue", WorkQueue::QOS::UserInteractive);

	for (size_t i = 0; i < iterationCount; ++i) {
	for (size_t j = 0; j < queueCount; ++j)
	queue[j]->dispatch([instance = std::make_unique<DestructionWorkQueueTester>(counter)]() { }); // NOLINT
	}
	for (size_t j = 0; j < queueCount; ++j)
	queue[j]->dispatchSync([] { });
	EXPECT_EQ(queueCount * iterationCount, counter);
	}

	namespace {
	struct AssertionTestHolder {
	const RefPtr<WorkQueue> queue { WorkQueue::create("com.apple.WebKit.Test.ThreadSafetyAnalysisAssertIsCurrentWorks", WorkQueue::QOS::UserInteractive) };
	size_t counter WTF_GUARDED_BY_CAPABILITY(*queue) { 0 };
	size_t result { 0 }; // This is here to support the result assertion. The compiler doesn't allow us to obtain the `counter` otherwise.

	void testTask()
	{
	assertIsCurrent(*queue); // This is being tested.
	++counter;
	}
	void computeResult() WTF_REQUIRES_CAPABILITY(*queue) // This is being tested.
	{
	result = ++counter;
	}
	template<typename T> void testTaskThatFailsToCompile()
	{
	++counter;
	}
	};
	}

	TEST(WTF_WorkQueue, ThreadSafetyAnalysisAssertIsCurrentWorks)
	{
	constexpr size_t queueCount = 50;
	constexpr size_t iterationCount = 10000;

	AssertionTestHolder holders[queueCount];
	for (size_t i = 0; i < iterationCount; ++i) {
	for (auto& holder : holders)
	holder.queue->dispatch([&holder] { holder.testTask(); });
	}
	// #define TEST_COMPILE_FAILURE
	#ifdef TEST_COMPILE_FAILURE
	for (auto& holder : holders)
	holder.queue->dispatchSync([&holder] { holder.testTaskThatFailsToCompile<int>(); });
	#endif
	for (auto& holder : holders)
	holder.queue->dispatchSync([&holder] { assertIsCurrent(*holder.queue); holder.computeResult(); });
	for (auto& holder : holders)
	EXPECT_EQ(iterationCount + 1, holder.result);
	}

	} // namespace TestWebKitAPI