RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 14:28:12 +00:00
Code Issues Activity Actions

Meta+AK: Make clang-format-10 clean

Browse source
This commit is contained in:
Ben Wiederhake 2020-09-18 09:49:51 +02:00 • committed by Andreas Kling
parent 468a29f4a1
commit 8940bc3503
28 changed files with 315 additions and 313 deletions
Download patch file Download diff file Expand all files Collapse all files

1
AK/Atomic.h
View file

@ -85,7 +85,6 @@ template<typename T, typename V = typename RemoveVolatile<T>::Type>
return __atomic_compare_exchange_n(const_cast<V**>(var), &expected, nullptr, false, order, order); return __atomic_compare_exchange_n(const_cast<V**>(var), &expected, nullptr, false, order, order);
} }
template<typename T> template<typename T>
static inline T atomic_fetch_add(volatile T* var, T val, MemoryOrder order = memory_order_seq_cst) noexcept static inline T atomic_fetch_add(volatile T* var, T val, MemoryOrder order = memory_order_seq_cst) noexcept
{ {

3
AK/Badge.h
View file

@ -31,7 +31,7 @@ namespace AK {
template<typename T> template<typename T>
class Badge { class Badge {
friend T; friend T;
Badge() {} Badge() { }
Badge(const Badge&) = delete; Badge(const Badge&) = delete;
Badge& operator=(const Badge&) = delete; Badge& operator=(const Badge&) = delete;
@ -43,4 +43,3 @@ class Badge {
} }
using AK::Badge; using AK::Badge;

4
AK/Function.h
View file

@ -38,7 +38,7 @@ template<typename Out, typename... In>
class Function<Out(In...)> { class Function<Out(In...)> {
public: public:
Function() = default; Function() = default;
Function(std::nullptr_t) {} Function(std::nullptr_t) { }
template<typename CallableType, class = typename EnableIf<!(IsPointer<CallableType>::value && IsFunction<typename RemovePointer<CallableType>::Type>::value) && IsRvalueReference<CallableType&&>::value>::Type> template<typename CallableType, class = typename EnableIf<!(IsPointer<CallableType>::value && IsFunction<typename RemovePointer<CallableType>::Type>::value) && IsRvalueReference<CallableType&&>::value>::Type>
Function(CallableType&& callable) Function(CallableType&& callable)
@ -83,7 +83,7 @@ public:
private: private:
class CallableWrapperBase { class CallableWrapperBase {
public: public:
virtual ~CallableWrapperBase() {} virtual ~CallableWrapperBase() { }
virtual Out call(In...) const = 0; virtual Out call(In...) const = 0;
}; };

1
AK/GenericLexer.cpp
View file

@ -276,7 +276,6 @@ void GenericLexer::ignore_until(Condition condition)
m_index++; m_index++;
} }
bool is_control(char c) bool is_control(char c)
{ {
return (c >= 0 && c <= 31) || c == 127; return (c >= 0 && c <= 31) || c == 127;

2
AK/HashFunctions.h
View file

@ -53,7 +53,7 @@ inline unsigned u64_hash(u64 key)
inline unsigned ptr_hash(FlatPtr ptr) inline unsigned ptr_hash(FlatPtr ptr)
{ {
if constexpr(sizeof(ptr) == 8) if constexpr (sizeof(ptr) == 8)
return u64_hash((u64)ptr); return u64_hash((u64)ptr);
else else
return int_hash((u32)ptr); return int_hash((u32)ptr);

2
AK/HashMap.h
View file

@ -47,7 +47,7 @@ private:
}; };
public: public:
HashMap() {} HashMap() { }
bool is_empty() const { return m_table.is_empty(); } bool is_empty() const { return m_table.is_empty(); }
size_t size() const { return m_table.size(); } size_t size() const { return m_table.size(); }

6
AK/IDAllocator.h
View file

@ -26,16 +26,16 @@
#pragma once #pragma once
#include <stdlib.h>
#include <AK/HashTable.h> #include <AK/HashTable.h>
#include <stdlib.h>
namespace AK { namespace AK {
class IDAllocator { class IDAllocator {
public: public:
IDAllocator() {} IDAllocator() { }
~IDAllocator() {} ~IDAllocator() { }
int allocate() int allocate()
{ {

2
AK/InlineLinkedList.h
View file

@ -104,7 +104,7 @@ inline T* InlineLinkedListNode<T>::next() const
template<typename T> template<typename T>
class InlineLinkedList { class InlineLinkedList {
public: public:
InlineLinkedList() {} InlineLinkedList() { }
bool is_empty() const { return !m_head; } bool is_empty() const { return !m_head; }
size_t size_slow() const; size_t size_slow() const;

4
AK/JsonArray.h
View file

@ -34,8 +34,8 @@ namespace AK {
class JsonArray { class JsonArray {
public: public:
JsonArray() {} JsonArray() { }
~JsonArray() {} ~JsonArray() { }
JsonArray(const JsonArray& other) JsonArray(const JsonArray& other)
: m_values(other.m_values) : m_values(other.m_values)

4
AK/JsonObject.h
View file

@ -37,8 +37,8 @@ namespace AK {
class JsonObject { class JsonObject {
public: public:
JsonObject() {} JsonObject() { }
~JsonObject() {} ~JsonObject() { }
JsonObject(const JsonObject& other) JsonObject(const JsonObject& other)
: m_order(other.m_order) : m_order(other.m_order)

6
AK/LexicalPath.cpp
View file

@ -92,10 +92,10 @@ void LexicalPath::canonicalize()
Optional<size_t> last_dot = StringView(m_basename).find_last_of('.'); Optional<size_t> last_dot = StringView(m_basename).find_last_of('.');
if (last_dot.has_value()) { if (last_dot.has_value()) {
m_title = m_basename.substring(0, last_dot.value()); m_title = m_basename.substring(0, last_dot.value());
m_extension = m_basename.substring(last_dot.value() + 1, m_basename.length() - last_dot.value() - 1); m_extension = m_basename.substring(last_dot.value() + 1, m_basename.length() - last_dot.value() - 1);
} else { } else {
m_title = m_basename; m_title = m_basename;
} }
StringBuilder builder(approximate_canonical_length); StringBuilder builder(approximate_canonical_length);

6
AK/MACAddress.h
View file

@ -33,7 +33,7 @@
class [[gnu::packed]] MACAddress class [[gnu::packed]] MACAddress
{ {
public: public:
MACAddress() {} MACAddress() { }
MACAddress(const u8 data[6]) MACAddress(const u8 data[6])
{ {
__builtin_memcpy(m_data, data, 6); __builtin_memcpy(m_data, data, 6);
@ -47,7 +47,7 @@ public:
m_data[4] = e; m_data[4] = e;
m_data[5] = f; m_data[5] = f;
} }
~MACAddress() {} ~MACAddress() { }
u8 operator[](int i) const u8 operator[](int i) const
{ {
@ -78,7 +78,7 @@ static_assert(sizeof(MACAddress) == 6);
namespace AK { namespace AK {
template <> template<>
struct Traits<MACAddress> : public GenericTraits<MACAddress> { struct Traits<MACAddress> : public GenericTraits<MACAddress> {
static unsigned hash(const MACAddress& address) { return string_hash((const char*)&address, sizeof(address)); } static unsigned hash(const MACAddress& address) { return string_hash((const char*)&address, sizeof(address)); }
}; };

5
AK/NonnullOwnPtrVector.h
View file

@ -26,14 +26,13 @@
#pragma once #pragma once
#include <AK/NonnullPtrVector.h>
#include <AK/NonnullOwnPtr.h> #include <AK/NonnullOwnPtr.h>
#include <AK/NonnullPtrVector.h>
namespace AK { namespace AK {
template<typename T, int inline_capacity = 0> template<typename T, int inline_capacity = 0>
class NonnullOwnPtrVector : public NonnullPtrVector<NonnullOwnPtr<T>, inline_capacity> class NonnullOwnPtrVector : public NonnullPtrVector<NonnullOwnPtr<T>, inline_capacity> {
{
}; };
} }

3
AK/NonnullRefPtrVector.h
View file

@ -32,8 +32,7 @@
namespace AK { namespace AK {
template<typename T, int inline_capacity = 0> template<typename T, int inline_capacity = 0>
class NonnullRefPtrVector : public NonnullPtrVector<NonnullRefPtr<T>, inline_capacity> class NonnullRefPtrVector : public NonnullPtrVector<NonnullRefPtr<T>, inline_capacity> {
{
}; };
} }

1
AK/Queue.h
View file

@ -88,4 +88,3 @@ private:
} }
using AK::Queue; using AK::Queue;

4
AK/RefPtr.h
View file

@ -44,7 +44,7 @@ public:
Adopt Adopt
}; };
RefPtr() {} RefPtr() { }
RefPtr(const T* ptr) RefPtr(const T* ptr)
: m_ptr(const_cast<T*>(ptr)) : m_ptr(const_cast<T*>(ptr))
{ {
@ -108,7 +108,7 @@ public:
m_ptr = (T*)(0xe0e0e0e0); m_ptr = (T*)(0xe0e0e0e0);
#endif #endif
} }
RefPtr(std::nullptr_t) {} RefPtr(std::nullptr_t) { }
template<typename U> template<typename U>
RefPtr(const OwnPtr<U>&) = delete; RefPtr(const OwnPtr<U>&) = delete;

9
AK/Result.h
View file

@ -32,7 +32,8 @@
namespace AK { namespace AK {
template<typename ValueType, typename ErrorType> template<typename ValueType, typename ErrorType>
class [[nodiscard]] Result { class [[nodiscard]] Result
{
public: public:
Result(const ValueType& res) Result(const ValueType& res)
: m_result(res) : m_result(res)
@ -50,13 +51,19 @@ public:
{ {
} }
// FIXME: clang-format gets confused about Result. Why?
// clang-format off
Result(Result&& other) Result(Result&& other)
// clang-format on
: m_result(move(other.m_result)) : m_result(move(other.m_result))
, m_error(move(other.m_error)) , m_error(move(other.m_error))
{ {
} }
// FIXME: clang-format gets confused about Result. Why?
// clang-format off
Result(Result& other) Result(Result& other)
// clang-format on
: m_result(other.m_result) : m_result(other.m_result)
, m_error(other.m_error) , m_error(other.m_error)
{ {

2
AK/ScopeGuard.h
View file

@ -70,5 +70,5 @@ private:
} }
using AK::ScopeGuard;
using AK::ArmedScopeGuard; using AK::ArmedScopeGuard;
using AK::ScopeGuard;

3
AK/Singleton.h
View file

@ -30,7 +30,7 @@
#include <AK/Atomic.h> #include <AK/Atomic.h>
#include <AK/kmalloc.h> #include <AK/kmalloc.h>
#ifdef KERNEL #ifdef KERNEL
#include <Kernel/Arch/i386/CPU.h> # include <Kernel/Arch/i386/CPU.h>
#endif #endif
#ifndef __serenity__ #ifndef __serenity__
@ -51,6 +51,7 @@ template<typename T, T* (*InitFunction)() = SingletonInstanceCreator<T>::create>
class Singleton { class Singleton {
AK_MAKE_NONCOPYABLE(Singleton); AK_MAKE_NONCOPYABLE(Singleton);
AK_MAKE_NONMOVABLE(Singleton); AK_MAKE_NONMOVABLE(Singleton);
public: public:
Singleton() = default; Singleton() = default;

4
AK/SinglyLinkedListWithCount.h
View file

@ -34,8 +34,8 @@ template<typename T>
class SinglyLinkedListWithCount : private SinglyLinkedList<T> { class SinglyLinkedListWithCount : private SinglyLinkedList<T> {
public: public:
SinglyLinkedListWithCount() {} SinglyLinkedListWithCount() { }
~SinglyLinkedListWithCount() {} ~SinglyLinkedListWithCount() { }
using List = SinglyLinkedList<T>; using List = SinglyLinkedList<T>;

514
AK/Tests/TestAtomic.cpp
View file

@ -30,335 +30,335 @@
TEST_CASE(construct_empty) TEST_CASE(construct_empty)
{ {
EXPECT(Atomic<bool>().load() == false); EXPECT(Atomic<bool>().load() == false);
EXPECT(Atomic<u32>().load() == 0); EXPECT(Atomic<u32>().load() == 0);
EXPECT(Atomic<u16>().load() == 0); EXPECT(Atomic<u16>().load() == 0);
EXPECT(Atomic<u8>().load() == 0); EXPECT(Atomic<u8>().load() == 0);
EXPECT(Atomic<u16*>().load() == nullptr); EXPECT(Atomic<u16*>().load() == nullptr);
} }
TEST_CASE(construct_with_value) TEST_CASE(construct_with_value)
{ {
EXPECT(Atomic<bool>(false).load() == false); EXPECT(Atomic<bool>(false).load() == false);
EXPECT(Atomic<bool>(true).load() == true); EXPECT(Atomic<bool>(true).load() == true);
EXPECT(Atomic<u32>(2).load() == 2); EXPECT(Atomic<u32>(2).load() == 2);
EXPECT(Atomic<u16>(3).load() == 3); EXPECT(Atomic<u16>(3).load() == 3);
EXPECT(Atomic<u8>(4).load() == 4); EXPECT(Atomic<u8>(4).load() == 4);
u16 v_u16 = 0; u16 v_u16 = 0;
EXPECT(Atomic<u16*>(&v_u16).load() == &v_u16); EXPECT(Atomic<u16*>(&v_u16).load() == &v_u16);
} }
TEST_CASE(do_exchange) TEST_CASE(do_exchange)
{ {
Atomic<bool> a_bool(false); Atomic<bool> a_bool(false);
EXPECT(a_bool.exchange(true) == false); EXPECT(a_bool.exchange(true) == false);
EXPECT(a_bool.load() == true && static_cast<bool>(a_bool) == true); EXPECT(a_bool.load() == true && static_cast<bool>(a_bool) == true);
Atomic<u32> a_u32(2); Atomic<u32> a_u32(2);
EXPECT(a_u32.exchange(22) == 2); EXPECT(a_u32.exchange(22) == 2);
EXPECT(a_u32.load() == 22 && static_cast<u8>(a_u32) == 22); EXPECT(a_u32.load() == 22 && static_cast<u8>(a_u32) == 22);
Atomic<u16> a_u16(3); Atomic<u16> a_u16(3);
EXPECT(a_u16.exchange(33) == 3); EXPECT(a_u16.exchange(33) == 3);
EXPECT(a_u16.load() == 33 && static_cast<u8>(a_u16) == 33); EXPECT(a_u16.load() == 33 && static_cast<u8>(a_u16) == 33);
Atomic<u8> a_u8(4); Atomic<u8> a_u8(4);
EXPECT(a_u8.exchange(44) == 4); EXPECT(a_u8.exchange(44) == 4);
EXPECT(a_u8.load() == 44 && static_cast<u8>(a_u8) == 44); EXPECT(a_u8.load() == 44 && static_cast<u8>(a_u8) == 44);
u16 v_u16[6]; u16 v_u16[6];
Atomic<u16*> a_pu16(&v_u16[2]); Atomic<u16*> a_pu16(&v_u16[2]);
EXPECT(a_pu16.load() == &v_u16[2] && static_cast<u16*>(a_pu16) == &v_u16[2]); EXPECT(a_pu16.load() == &v_u16[2] && static_cast<u16*>(a_pu16) == &v_u16[2]);
} }
TEST_CASE(do_compare_exchange) TEST_CASE(do_compare_exchange)
{ {
Atomic<bool> a_bool(false); Atomic<bool> a_bool(false);
bool e_bool = true; bool e_bool = true;
EXPECT(a_bool.compare_exchange_strong(e_bool, true) == false); EXPECT(a_bool.compare_exchange_strong(e_bool, true) == false);
EXPECT(e_bool == false); EXPECT(e_bool == false);
EXPECT(a_bool.load() == false && static_cast<bool>(a_bool) == false); EXPECT(a_bool.load() == false && static_cast<bool>(a_bool) == false);
e_bool = false; e_bool = false;
EXPECT(a_bool.compare_exchange_strong(e_bool, true) == true); EXPECT(a_bool.compare_exchange_strong(e_bool, true) == true);
EXPECT(a_bool.load() == true && static_cast<bool>(a_bool) == true); EXPECT(a_bool.load() == true && static_cast<bool>(a_bool) == true);
Atomic<u32> a_u32(2); Atomic<u32> a_u32(2);
u32 e_u32 = 99; u32 e_u32 = 99;
EXPECT(a_u32.compare_exchange_strong(e_u32, 22) == false); EXPECT(a_u32.compare_exchange_strong(e_u32, 22) == false);
EXPECT(e_u32 == 2); EXPECT(e_u32 == 2);
EXPECT(a_u32.load() == 2 && static_cast<u32>(a_u32) == 2); EXPECT(a_u32.load() == 2 && static_cast<u32>(a_u32) == 2);
e_u32 = 2; e_u32 = 2;
EXPECT(a_u32.compare_exchange_strong(e_u32, 22) == true); EXPECT(a_u32.compare_exchange_strong(e_u32, 22) == true);
EXPECT(a_u32.load() == 22 && static_cast<u32>(a_u32) == 22); EXPECT(a_u32.load() == 22 && static_cast<u32>(a_u32) == 22);
Atomic<u16> a_u16(3); Atomic<u16> a_u16(3);
u16 e_u16 = 99; u16 e_u16 = 99;
EXPECT(a_u16.compare_exchange_strong(e_u16, 33) == false); EXPECT(a_u16.compare_exchange_strong(e_u16, 33) == false);
EXPECT(e_u16 == 3); EXPECT(e_u16 == 3);
EXPECT(a_u16.load() == 3 && static_cast<u16>(a_u16) == 3); EXPECT(a_u16.load() == 3 && static_cast<u16>(a_u16) == 3);
e_u16 = 3; e_u16 = 3;
EXPECT(a_u16.compare_exchange_strong(e_u16, 33) == true); EXPECT(a_u16.compare_exchange_strong(e_u16, 33) == true);
EXPECT(a_u16.load() == 33 && static_cast<u16>(a_u16) == 33); EXPECT(a_u16.load() == 33 && static_cast<u16>(a_u16) == 33);
Atomic<u8> a_u8(4); Atomic<u8> a_u8(4);
u8 e_u8 = 99; u8 e_u8 = 99;
EXPECT(a_u8.compare_exchange_strong(e_u8, 44) == false); EXPECT(a_u8.compare_exchange_strong(e_u8, 44) == false);
EXPECT(e_u8 == 4); EXPECT(e_u8 == 4);
EXPECT(a_u8.load() == 4 && static_cast<u16>(a_u8) == 4); EXPECT(a_u8.load() == 4 && static_cast<u16>(a_u8) == 4);
e_u8 = 4; e_u8 = 4;
EXPECT(a_u8.compare_exchange_strong(e_u8, 44) == true); EXPECT(a_u8.compare_exchange_strong(e_u8, 44) == true);
EXPECT(a_u8.load() == 44 && static_cast<u16>(a_u8) == 44); EXPECT(a_u8.load() == 44 && static_cast<u16>(a_u8) == 44);
} }
TEST_CASE(fetch_add) TEST_CASE(fetch_add)
{ {
Atomic<u32> a_u32(5); Atomic<u32> a_u32(5);
EXPECT(a_u32.fetch_add(2) == 5); EXPECT(a_u32.fetch_add(2) == 5);
EXPECT(a_u32.load() == 7 && static_cast<u32>(a_u32) == 7); EXPECT(a_u32.load() == 7 && static_cast<u32>(a_u32) == 7);
Atomic<u16> a_u16(5); Atomic<u16> a_u16(5);
EXPECT(a_u16.fetch_add(2) == 5); EXPECT(a_u16.fetch_add(2) == 5);
EXPECT(a_u16.load() == 7 && static_cast<u16>(a_u16) == 7); EXPECT(a_u16.load() == 7 && static_cast<u16>(a_u16) == 7);
Atomic<u8> a_u8(5); Atomic<u8> a_u8(5);
EXPECT(a_u8.fetch_add(2) == 5); EXPECT(a_u8.fetch_add(2) == 5);
EXPECT(a_u8.load() == 7 && static_cast<u8>(a_u8) == 7); EXPECT(a_u8.load() == 7 && static_cast<u8>(a_u8) == 7);
u32 v_u32[6]; u32 v_u32[6];
Atomic<u32*> a_pu32(&v_u32[2]); Atomic<u32*> a_pu32(&v_u32[2]);
EXPECT(a_pu32.load() == &v_u32[2] && static_cast<u32*>(a_pu32) == &v_u32[2]); EXPECT(a_pu32.load() == &v_u32[2] && static_cast<u32*>(a_pu32) == &v_u32[2]);
EXPECT(a_pu32.fetch_add(2) == &v_u32[2]); EXPECT(a_pu32.fetch_add(2) == &v_u32[2]);
EXPECT(a_pu32.load() == &v_u32[4] && static_cast<u32*>(a_pu32) == &v_u32[4]); EXPECT(a_pu32.load() == &v_u32[4] && static_cast<u32*>(a_pu32) == &v_u32[4]);
EXPECT(a_pu32.fetch_add(-3) == &v_u32[4]); EXPECT(a_pu32.fetch_add(-3) == &v_u32[4]);
EXPECT(a_pu32.load() == &v_u32[1] && static_cast<u32*>(a_pu32) == &v_u32[1]); EXPECT(a_pu32.load() == &v_u32[1] && static_cast<u32*>(a_pu32) == &v_u32[1]);
u16 v_u16[6]; u16 v_u16[6];
Atomic<u16*> a_pu16(&v_u16[2]); Atomic<u16*> a_pu16(&v_u16[2]);
EXPECT(a_pu16.load() == &v_u16[2] && static_cast<u16*>(a_pu16) == &v_u16[2]); EXPECT(a_pu16.load() == &v_u16[2] && static_cast<u16*>(a_pu16) == &v_u16[2]);
EXPECT(a_pu16.fetch_add(2) == &v_u16[2]); EXPECT(a_pu16.fetch_add(2) == &v_u16[2]);
EXPECT(a_pu16.load() == &v_u16[4] && static_cast<u16*>(a_pu16) == &v_u16[4]); EXPECT(a_pu16.load() == &v_u16[4] && static_cast<u16*>(a_pu16) == &v_u16[4]);
EXPECT(a_pu16.fetch_add(-3) == &v_u16[4]); EXPECT(a_pu16.fetch_add(-3) == &v_u16[4]);
EXPECT(a_pu16.load() == &v_u16[1] && static_cast<u16*>(a_pu16) == &v_u16[1]); EXPECT(a_pu16.load() == &v_u16[1] && static_cast<u16*>(a_pu16) == &v_u16[1]);
u8 v_u8[6]; u8 v_u8[6];
Atomic<u8*> a_pu8(&v_u8[2]); Atomic<u8*> a_pu8(&v_u8[2]);
EXPECT(a_pu8.load() == &v_u8[2] && static_cast<u8*>(a_pu8) == &v_u8[2]); EXPECT(a_pu8.load() == &v_u8[2] && static_cast<u8*>(a_pu8) == &v_u8[2]);
EXPECT(a_pu8.fetch_add(2) == &v_u8[2]); EXPECT(a_pu8.fetch_add(2) == &v_u8[2]);
EXPECT(a_pu8.load() == &v_u8[4] && static_cast<u8*>(a_pu8) == &v_u8[4]); EXPECT(a_pu8.load() == &v_u8[4] && static_cast<u8*>(a_pu8) == &v_u8[4]);
EXPECT(a_pu8.fetch_add(-3) == &v_u8[4]); EXPECT(a_pu8.fetch_add(-3) == &v_u8[4]);
EXPECT(a_pu8.load() == &v_u8[1] && static_cast<u8*>(a_pu8) == &v_u8[1]); EXPECT(a_pu8.load() == &v_u8[1] && static_cast<u8*>(a_pu8) == &v_u8[1]);
} }
TEST_CASE(fetch_sub) TEST_CASE(fetch_sub)
{ {
Atomic<u32> a_u32(5); Atomic<u32> a_u32(5);
EXPECT(a_u32.fetch_sub(2) == 5); EXPECT(a_u32.fetch_sub(2) == 5);
EXPECT(a_u32.load() == 3 && static_cast<u32>(a_u32) == 3); EXPECT(a_u32.load() == 3 && static_cast<u32>(a_u32) == 3);
Atomic<u16> a_u16(5); Atomic<u16> a_u16(5);
EXPECT(a_u16.fetch_sub(2) == 5); EXPECT(a_u16.fetch_sub(2) == 5);
EXPECT(a_u16.load() == 3 && static_cast<u16>(a_u16) == 3); EXPECT(a_u16.load() == 3 && static_cast<u16>(a_u16) == 3);
Atomic<u8> a_u8(5); Atomic<u8> a_u8(5);
EXPECT(a_u8.fetch_sub(2) == 5); EXPECT(a_u8.fetch_sub(2) == 5);
EXPECT(a_u8.load() == 3 && static_cast<u8>(a_u8) == 3); EXPECT(a_u8.load() == 3 && static_cast<u8>(a_u8) == 3);
u32 v_u32[6]; u32 v_u32[6];
Atomic<u32*> a_pu32(&v_u32[2]); Atomic<u32*> a_pu32(&v_u32[2]);
EXPECT(a_pu32.load() == &v_u32[2] && static_cast<u32*>(a_pu32) == &v_u32[2]); EXPECT(a_pu32.load() == &v_u32[2] && static_cast<u32*>(a_pu32) == &v_u32[2]);
EXPECT(a_pu32.fetch_sub(2) == &v_u32[2]); EXPECT(a_pu32.fetch_sub(2) == &v_u32[2]);
EXPECT(a_pu32.load() == &v_u32[0] && static_cast<u32*>(a_pu32) == &v_u32[0]); EXPECT(a_pu32.load() == &v_u32[0] && static_cast<u32*>(a_pu32) == &v_u32[0]);
EXPECT(a_pu32.fetch_sub(-3) == &v_u32[0]); EXPECT(a_pu32.fetch_sub(-3) == &v_u32[0]);
EXPECT(a_pu32.load() == &v_u32[3] && static_cast<u32*>(a_pu32) == &v_u32[3]); EXPECT(a_pu32.load() == &v_u32[3] && static_cast<u32*>(a_pu32) == &v_u32[3]);
u16 v_u16[6]; u16 v_u16[6];
Atomic<u16*> a_pu16(&v_u16[2]); Atomic<u16*> a_pu16(&v_u16[2]);
EXPECT(a_pu16.load() == &v_u16[2] && static_cast<u16*>(a_pu16) == &v_u16[2]); EXPECT(a_pu16.load() == &v_u16[2] && static_cast<u16*>(a_pu16) == &v_u16[2]);
EXPECT(a_pu16.fetch_sub(2) == &v_u16[2]); EXPECT(a_pu16.fetch_sub(2) == &v_u16[2]);
EXPECT(a_pu16.load() == &v_u16[0] && static_cast<u16*>(a_pu16) == &v_u16[0]); EXPECT(a_pu16.load() == &v_u16[0] && static_cast<u16*>(a_pu16) == &v_u16[0]);
EXPECT(a_pu16.fetch_sub(-3) == &v_u16[0]); EXPECT(a_pu16.fetch_sub(-3) == &v_u16[0]);
EXPECT(a_pu16.load() == &v_u16[3] && static_cast<u16*>(a_pu16) == &v_u16[3]); EXPECT(a_pu16.load() == &v_u16[3] && static_cast<u16*>(a_pu16) == &v_u16[3]);
u8 v_u8[6]; u8 v_u8[6];
Atomic<u8*> a_pu8(&v_u8[2]); Atomic<u8*> a_pu8(&v_u8[2]);
EXPECT(a_pu8.load() == &v_u8[2] && static_cast<u8*>(a_pu8) == &v_u8[2]); EXPECT(a_pu8.load() == &v_u8[2] && static_cast<u8*>(a_pu8) == &v_u8[2]);
EXPECT(a_pu8.fetch_sub(2) == &v_u8[2]); EXPECT(a_pu8.fetch_sub(2) == &v_u8[2]);
EXPECT(a_pu8.load() == &v_u8[0] && static_cast<u8*>(a_pu8) == &v_u8[0]); EXPECT(a_pu8.load() == &v_u8[0] && static_cast<u8*>(a_pu8) == &v_u8[0]);
EXPECT(a_pu8.fetch_sub(-3) == &v_u8[0]); EXPECT(a_pu8.fetch_sub(-3) == &v_u8[0]);
EXPECT(a_pu8.load() == &v_u8[3] && static_cast<u8*>(a_pu8) == &v_u8[3]); EXPECT(a_pu8.load() == &v_u8[3] && static_cast<u8*>(a_pu8) == &v_u8[3]);
} }
TEST_CASE(fetch_inc) TEST_CASE(fetch_inc)
{ {
Atomic<u32> a_u32(5); Atomic<u32> a_u32(5);
EXPECT(a_u32++ == 5); EXPECT(a_u32++ == 5);
EXPECT(a_u32.load() == 6 && a_u32 == 6); EXPECT(a_u32.load() == 6 && a_u32 == 6);
EXPECT(++a_u32 == 7); EXPECT(++a_u32 == 7);
EXPECT(a_u32.load() == 7 && a_u32 == 7); EXPECT(a_u32.load() == 7 && a_u32 == 7);
EXPECT((a_u32 += 2) == 9); EXPECT((a_u32 += 2) == 9);
EXPECT(a_u32.load() == 9 && a_u32 == 9); EXPECT(a_u32.load() == 9 && a_u32 == 9);
Atomic<u16> a_u16(5); Atomic<u16> a_u16(5);
EXPECT(a_u16++ == 5); EXPECT(a_u16++ == 5);
EXPECT(a_u16.load() == 6 && a_u16 == 6); EXPECT(a_u16.load() == 6 && a_u16 == 6);
EXPECT(++a_u16 == 7); EXPECT(++a_u16 == 7);
EXPECT(a_u16.load() == 7 && a_u16 == 7); EXPECT(a_u16.load() == 7 && a_u16 == 7);
EXPECT((a_u16 += 2) == 9); EXPECT((a_u16 += 2) == 9);
EXPECT(a_u16.load() == 9 && a_u16 == 9); EXPECT(a_u16.load() == 9 && a_u16 == 9);
Atomic<u8> a_u8(5); Atomic<u8> a_u8(5);
EXPECT(a_u8++ == 5); EXPECT(a_u8++ == 5);
EXPECT(a_u8.load() == 6 && a_u8 == 6); EXPECT(a_u8.load() == 6 && a_u8 == 6);
EXPECT(++a_u8 == 7); EXPECT(++a_u8 == 7);
EXPECT(a_u8.load() == 7 && a_u8 == 7); EXPECT(a_u8.load() == 7 && a_u8 == 7);
EXPECT((a_u8 += 2) == 9); EXPECT((a_u8 += 2) == 9);
EXPECT(a_u8.load() == 9 && a_u8 == 9); EXPECT(a_u8.load() == 9 && a_u8 == 9);
u32 v_u32[8]; u32 v_u32[8];
Atomic<u32*> a_pu32(&v_u32[2]); Atomic<u32*> a_pu32(&v_u32[2]);
EXPECT(a_pu32++ == &v_u32[2]); EXPECT(a_pu32++ == &v_u32[2]);
EXPECT(a_pu32.load() == &v_u32[3] && a_pu32 == &v_u32[3]); EXPECT(a_pu32.load() == &v_u32[3] && a_pu32 == &v_u32[3]);
EXPECT(++a_pu32 == &v_u32[4]); EXPECT(++a_pu32 == &v_u32[4]);
EXPECT(a_pu32.load() == &v_u32[4] && a_pu32 == &v_u32[4]); EXPECT(a_pu32.load() == &v_u32[4] && a_pu32 == &v_u32[4]);
EXPECT((a_pu32 += 2) == &v_u32[6]); EXPECT((a_pu32 += 2) == &v_u32[6]);
EXPECT(a_pu32.load() == &v_u32[6] && a_pu32 == &v_u32[6]); EXPECT(a_pu32.load() == &v_u32[6] && a_pu32 == &v_u32[6]);
u16 v_u16[8]; u16 v_u16[8];
Atomic<u16*> a_pu16(&v_u16[2]); Atomic<u16*> a_pu16(&v_u16[2]);
EXPECT(a_pu16++ == &v_u16[2]); EXPECT(a_pu16++ == &v_u16[2]);
EXPECT(a_pu16.load() == &v_u16[3] && a_pu16 == &v_u16[3]); EXPECT(a_pu16.load() == &v_u16[3] && a_pu16 == &v_u16[3]);
EXPECT(++a_pu16 == &v_u16[4]); EXPECT(++a_pu16 == &v_u16[4]);
EXPECT(a_pu16.load() == &v_u16[4] && a_pu16 == &v_u16[4]); EXPECT(a_pu16.load() == &v_u16[4] && a_pu16 == &v_u16[4]);
EXPECT((a_pu16 += 2) == &v_u16[6]); EXPECT((a_pu16 += 2) == &v_u16[6]);
EXPECT(a_pu16.load() == &v_u16[6] && a_pu16 == &v_u16[6]); EXPECT(a_pu16.load() == &v_u16[6] && a_pu16 == &v_u16[6]);
u8 v_u8[8]; u8 v_u8[8];
Atomic<u8*> a_pu8(&v_u8[2]); Atomic<u8*> a_pu8(&v_u8[2]);
EXPECT(a_pu8++ == &v_u8[2]); EXPECT(a_pu8++ == &v_u8[2]);
EXPECT(a_pu8.load() == &v_u8[3] && a_pu8 == &v_u8[3]); EXPECT(a_pu8.load() == &v_u8[3] && a_pu8 == &v_u8[3]);
EXPECT(++a_pu8 == &v_u8[4]); EXPECT(++a_pu8 == &v_u8[4]);
EXPECT(a_pu8.load() == &v_u8[4] && a_pu8 == &v_u8[4]); EXPECT(a_pu8.load() == &v_u8[4] && a_pu8 == &v_u8[4]);
EXPECT((a_pu8 += 2) == &v_u8[6]); EXPECT((a_pu8 += 2) == &v_u8[6]);
EXPECT(a_pu8.load() == &v_u8[6] && a_pu8 == &v_u8[6]); EXPECT(a_pu8.load() == &v_u8[6] && a_pu8 == &v_u8[6]);
} }
TEST_CASE(fetch_dec) TEST_CASE(fetch_dec)
{ {
Atomic<u32> a_u32(5); Atomic<u32> a_u32(5);
EXPECT(a_u32-- == 5); EXPECT(a_u32-- == 5);
EXPECT(a_u32.load() == 4 && a_u32 == 4); EXPECT(a_u32.load() == 4 && a_u32 == 4);
EXPECT(--a_u32 == 3); EXPECT(--a_u32 == 3);
EXPECT(a_u32.load() == 3 && a_u32 == 3); EXPECT(a_u32.load() == 3 && a_u32 == 3);
EXPECT((a_u32 -= 2) == 1); EXPECT((a_u32 -= 2) == 1);
EXPECT(a_u32.load() == 1 && a_u32 == 1); EXPECT(a_u32.load() == 1 && a_u32 == 1);
Atomic<u16> a_u16(5); Atomic<u16> a_u16(5);
EXPECT(a_u16-- == 5); EXPECT(a_u16-- == 5);
EXPECT(a_u16.load() == 4 && a_u16 == 4); EXPECT(a_u16.load() == 4 && a_u16 == 4);
EXPECT(--a_u16 == 3); EXPECT(--a_u16 == 3);
EXPECT(a_u16.load() == 3 && a_u16 == 3); EXPECT(a_u16.load() == 3 && a_u16 == 3);
EXPECT((a_u16 -= 2) == 1); EXPECT((a_u16 -= 2) == 1);
EXPECT(a_u16.load() == 1 && a_u16 == 1); EXPECT(a_u16.load() == 1 && a_u16 == 1);
Atomic<u8> a_u8(5); Atomic<u8> a_u8(5);
EXPECT(a_u8-- == 5); EXPECT(a_u8-- == 5);
EXPECT(a_u8.load() == 4 && a_u8 == 4); EXPECT(a_u8.load() == 4 && a_u8 == 4);
EXPECT(--a_u8 == 3); EXPECT(--a_u8 == 3);
EXPECT(a_u8.load() == 3 && a_u8 == 3); EXPECT(a_u8.load() == 3 && a_u8 == 3);
EXPECT((a_u8 -= 2) == 1); EXPECT((a_u8 -= 2) == 1);
EXPECT(a_u8.load() == 1 && a_u8 == 1); EXPECT(a_u8.load() == 1 && a_u8 == 1);
u32 v_u32[8]; u32 v_u32[8];
Atomic<u32*> a_pu32(&v_u32[7]); Atomic<u32*> a_pu32(&v_u32[7]);
EXPECT(a_pu32-- == &v_u32[7]); EXPECT(a_pu32-- == &v_u32[7]);
EXPECT(a_pu32.load() == &v_u32[6] && a_pu32 == &v_u32[6]); EXPECT(a_pu32.load() == &v_u32[6] && a_pu32 == &v_u32[6]);
EXPECT(--a_pu32 == &v_u32[5]); EXPECT(--a_pu32 == &v_u32[5]);
EXPECT(a_pu32.load() == &v_u32[5] && a_pu32 == &v_u32[5]); EXPECT(a_pu32.load() == &v_u32[5] && a_pu32 == &v_u32[5]);
EXPECT((a_pu32 -= 2) == &v_u32[3]); EXPECT((a_pu32 -= 2) == &v_u32[3]);
EXPECT(a_pu32.load() == &v_u32[3] && a_pu32 == &v_u32[3]); EXPECT(a_pu32.load() == &v_u32[3] && a_pu32 == &v_u32[3]);
u16 v_u16[8]; u16 v_u16[8];
Atomic<u16*> a_pu16(&v_u16[7]); Atomic<u16*> a_pu16(&v_u16[7]);
EXPECT(a_pu16-- == &v_u16[7]); EXPECT(a_pu16-- == &v_u16[7]);
EXPECT(a_pu16.load() == &v_u16[6] && a_pu16 == &v_u16[6]); EXPECT(a_pu16.load() == &v_u16[6] && a_pu16 == &v_u16[6]);
EXPECT(--a_pu16 == &v_u16[5]); EXPECT(--a_pu16 == &v_u16[5]);
EXPECT(a_pu16.load() == &v_u16[5] && a_pu16 == &v_u16[5]); EXPECT(a_pu16.load() == &v_u16[5] && a_pu16 == &v_u16[5]);
EXPECT((a_pu16 -= 2) == &v_u16[3]); EXPECT((a_pu16 -= 2) == &v_u16[3]);
EXPECT(a_pu16.load() == &v_u16[3] && a_pu16 == &v_u16[3]); EXPECT(a_pu16.load() == &v_u16[3] && a_pu16 == &v_u16[3]);
u8 v_u8[8]; u8 v_u8[8];
Atomic<u8*> a_pu8(&v_u8[7]); Atomic<u8*> a_pu8(&v_u8[7]);
EXPECT(a_pu8-- == &v_u8[7]); EXPECT(a_pu8-- == &v_u8[7]);
EXPECT(a_pu8.load() == &v_u8[6] && a_pu8 == &v_u8[6]); EXPECT(a_pu8.load() == &v_u8[6] && a_pu8 == &v_u8[6]);
EXPECT(--a_pu8 == &v_u8[5]); EXPECT(--a_pu8 == &v_u8[5]);
EXPECT(a_pu8.load() == &v_u8[5] && a_pu8 == &v_u8[5]); EXPECT(a_pu8.load() == &v_u8[5] && a_pu8 == &v_u8[5]);
EXPECT((a_pu8 -= 2) == &v_u8[3]); EXPECT((a_pu8 -= 2) == &v_u8[3]);
EXPECT(a_pu8.load() == &v_u8[3] && a_pu8 == &v_u8[3]); EXPECT(a_pu8.load() == &v_u8[3] && a_pu8 == &v_u8[3]);
} }
TEST_CASE(fetch_and) TEST_CASE(fetch_and)
{ {
Atomic<u32> a_u32(0xdeadbeef); Atomic<u32> a_u32(0xdeadbeef);
EXPECT(a_u32.fetch_and(0x8badf00d) == 0xdeadbeef); EXPECT(a_u32.fetch_and(0x8badf00d) == 0xdeadbeef);
EXPECT(a_u32.load() == 0x8aadb00d && static_cast<u32>(a_u32) == 0x8aadb00d); EXPECT(a_u32.load() == 0x8aadb00d && static_cast<u32>(a_u32) == 0x8aadb00d);
a_u32 = 0xdeadbeef; a_u32 = 0xdeadbeef;
EXPECT((a_u32 &= 0x8badf00d) == 0x8aadb00d); EXPECT((a_u32 &= 0x8badf00d) == 0x8aadb00d);
Atomic<u16> a_u16(0xbeef); Atomic<u16> a_u16(0xbeef);
EXPECT(a_u16.fetch_and(0xf00d) == 0xbeef); EXPECT(a_u16.fetch_and(0xf00d) == 0xbeef);
EXPECT(a_u16.load() == 0xb00d && static_cast<u16>(a_u16) == 0xb00d); EXPECT(a_u16.load() == 0xb00d && static_cast<u16>(a_u16) == 0xb00d);
a_u16 = 0xbeef; a_u16 = 0xbeef;
EXPECT((a_u16 &= 0xf00d) == 0xb00d); EXPECT((a_u16 &= 0xf00d) == 0xb00d);
Atomic<u8> a_u8(0xef); Atomic<u8> a_u8(0xef);
EXPECT(a_u8.fetch_and(0x0d) == 0xef); EXPECT(a_u8.fetch_and(0x0d) == 0xef);
EXPECT(a_u8.load() == 0x0d && static_cast<u8>(a_u8) == 0x0d); EXPECT(a_u8.load() == 0x0d && static_cast<u8>(a_u8) == 0x0d);
a_u8 = 0xef; a_u8 = 0xef;
EXPECT((a_u8 &= 0x0d) == 0x0d); EXPECT((a_u8 &= 0x0d) == 0x0d);
} }
TEST_CASE(fetch_or) TEST_CASE(fetch_or)
{ {
Atomic<u32> a_u32(0xaadb00d); Atomic<u32> a_u32(0xaadb00d);
EXPECT(a_u32.fetch_or(0xdeadbeef) == 0xaadb00d); EXPECT(a_u32.fetch_or(0xdeadbeef) == 0xaadb00d);
EXPECT(a_u32.load() == 0xdeadbeef && static_cast<u32>(a_u32) == 0xdeadbeef); EXPECT(a_u32.load() == 0xdeadbeef && static_cast<u32>(a_u32) == 0xdeadbeef);
a_u32 = 0xaadb00d; a_u32 = 0xaadb00d;
EXPECT((a_u32 |= 0xdeadbeef) == 0xdeadbeef); EXPECT((a_u32 |= 0xdeadbeef) == 0xdeadbeef);
Atomic<u16> a_u16(0xb00d); Atomic<u16> a_u16(0xb00d);
EXPECT(a_u16.fetch_or(0xbeef) == 0xb00d); EXPECT(a_u16.fetch_or(0xbeef) == 0xb00d);
EXPECT(a_u16.load() == 0xbeef && static_cast<u16>(a_u16) == 0xbeef); EXPECT(a_u16.load() == 0xbeef && static_cast<u16>(a_u16) == 0xbeef);
a_u16 = 0xb00d; a_u16 = 0xb00d;
EXPECT((a_u16 |= 0xbeef) == 0xbeef); EXPECT((a_u16 |= 0xbeef) == 0xbeef);
Atomic<u8> a_u8(0x0d); Atomic<u8> a_u8(0x0d);
EXPECT(a_u8.fetch_or(0xef) == 0x0d); EXPECT(a_u8.fetch_or(0xef) == 0x0d);
EXPECT(a_u8.load() == 0xef && static_cast<u8>(a_u8) == 0xef); EXPECT(a_u8.load() == 0xef && static_cast<u8>(a_u8) == 0xef);
a_u8 = 0x0d; a_u8 = 0x0d;
EXPECT((a_u8 |= 0xef) == 0xef); EXPECT((a_u8 |= 0xef) == 0xef);
} }
TEST_CASE(fetch_xor) TEST_CASE(fetch_xor)
{ {
Atomic<u32> a_u32(0x55004ee2); Atomic<u32> a_u32(0x55004ee2);
EXPECT(a_u32.fetch_xor(0xdeadbeef) == 0x55004ee2); EXPECT(a_u32.fetch_xor(0xdeadbeef) == 0x55004ee2);
EXPECT(a_u32.load() == 0x8badf00d && static_cast<u32>(a_u32) == 0x8badf00d); EXPECT(a_u32.load() == 0x8badf00d && static_cast<u32>(a_u32) == 0x8badf00d);
a_u32 = 0x55004ee2; a_u32 = 0x55004ee2;
EXPECT((a_u32 ^= 0xdeadbeef) == 0x8badf00d); EXPECT((a_u32 ^= 0xdeadbeef) == 0x8badf00d);
Atomic<u16> a_u16(0x4ee2); Atomic<u16> a_u16(0x4ee2);
EXPECT(a_u16.fetch_xor(0xbeef) == 0x4ee2); EXPECT(a_u16.fetch_xor(0xbeef) == 0x4ee2);
EXPECT(a_u16.load() == 0xf00d && static_cast<u16>(a_u16) == 0xf00d); EXPECT(a_u16.load() == 0xf00d && static_cast<u16>(a_u16) == 0xf00d);
a_u16 = 0x4ee2; a_u16 = 0x4ee2;
EXPECT((a_u16 ^= 0xbeef) == 0xf00d); EXPECT((a_u16 ^= 0xbeef) == 0xf00d);
Atomic<u8> a_u8(0xe2); Atomic<u8> a_u8(0xe2);
EXPECT(a_u8.fetch_xor(0xef) == 0xe2); EXPECT(a_u8.fetch_xor(0xef) == 0xe2);
EXPECT(a_u8.load() == 0x0d && static_cast<u8>(a_u8) == 0x0d); EXPECT(a_u8.load() == 0x0d && static_cast<u8>(a_u8) == 0x0d);
a_u8 = 0xe2; a_u8 = 0xe2;
EXPECT((a_u8 ^= 0xef) == 0x0d); EXPECT((a_u8 ^= 0xef) == 0x0d);
} }
TEST_MAIN(Atomic) TEST_MAIN(Atomic)

2
AK/Tests/TestCircularDeque.cpp
View file

@ -59,7 +59,7 @@ TEST_CASE(enqueue_begin_being_moved_from)
{ {
CircularDeque<String, 2> strings; CircularDeque<String, 2> strings;
String str{"test"}; String str { "test" };
strings.enqueue_begin(move(str)); strings.enqueue_begin(move(str));
EXPECT(str.is_null()); EXPECT(str.is_null());
} }

2
AK/Tests/TestOptional.cpp
View file

@ -26,8 +26,8 @@
#include <AK/TestSuite.h> #include <AK/TestSuite.h>
#include <AK/String.h>
#include <AK/Optional.h> #include <AK/Optional.h>
#include <AK/String.h>
TEST_CASE(basic_optional) TEST_CASE(basic_optional)
{ {

2
AK/Tests/TestQueue.cpp
View file

@ -26,8 +26,8 @@
#include <AK/TestSuite.h> #include <AK/TestSuite.h>
#include <AK/String.h>
#include <AK/Queue.h> #include <AK/Queue.h>
#include <AK/String.h>
TEST_CASE(construct) TEST_CASE(construct)
{ {

16
AK/Tests/TestRefPtr.cpp
View file

@ -80,14 +80,14 @@ TEST_CASE(assign_copy_self)
RefPtr<Object> object = adopt(*new Object); RefPtr<Object> object = adopt(*new Object);
EXPECT_EQ(object->ref_count(), 1u); EXPECT_EQ(object->ref_count(), 1u);
#ifdef __clang__ #ifdef __clang__
#pragma clang diagnostic push # pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wself-assign-overloaded" # pragma clang diagnostic ignored "-Wself-assign-overloaded"
#endif #endif
object = object; object = object;
#ifdef __clang__ #ifdef __clang__
#pragma clang diagnostic pop # pragma clang diagnostic pop
#endif #endif
EXPECT_EQ(object->ref_count(), 1u); EXPECT_EQ(object->ref_count(), 1u);
} }

12
AK/Tests/TestStringUtils.cpp
View file

@ -157,22 +157,22 @@ TEST_CASE(ends_with)
{ {
String test_string = "ABCDEF"; String test_string = "ABCDEF";
EXPECT(AK::StringUtils::ends_with(test_string, "DEF", CaseSensitivity::CaseSensitive)); EXPECT(AK::StringUtils::ends_with(test_string, "DEF", CaseSensitivity::CaseSensitive));
EXPECT(AK::StringUtils::ends_with(test_string, "ABCDEF", CaseSensitivity::CaseSensitive)); EXPECT(AK::StringUtils::ends_with(test_string, "ABCDEF", CaseSensitivity::CaseSensitive));
EXPECT(!AK::StringUtils::ends_with(test_string, "ABCDE", CaseSensitivity::CaseSensitive)); EXPECT(!AK::StringUtils::ends_with(test_string, "ABCDE", CaseSensitivity::CaseSensitive));
EXPECT(!AK::StringUtils::ends_with(test_string, "ABCDEFG", CaseSensitivity::CaseSensitive)); EXPECT(!AK::StringUtils::ends_with(test_string, "ABCDEFG", CaseSensitivity::CaseSensitive));
EXPECT(AK::StringUtils::ends_with(test_string, "def", CaseSensitivity::CaseInsensitive)); EXPECT(AK::StringUtils::ends_with(test_string, "def", CaseSensitivity::CaseInsensitive));
EXPECT(!AK::StringUtils::ends_with(test_string, "def", CaseSensitivity::CaseSensitive)); EXPECT(!AK::StringUtils::ends_with(test_string, "def", CaseSensitivity::CaseSensitive));
} }
TEST_CASE(starts_with) TEST_CASE(starts_with)
{ {
String test_string = "ABCDEF"; String test_string = "ABCDEF";
EXPECT(AK::StringUtils::starts_with(test_string, "ABC", CaseSensitivity::CaseSensitive)); EXPECT(AK::StringUtils::starts_with(test_string, "ABC", CaseSensitivity::CaseSensitive));
EXPECT(AK::StringUtils::starts_with(test_string, "ABCDEF", CaseSensitivity::CaseSensitive)); EXPECT(AK::StringUtils::starts_with(test_string, "ABCDEF", CaseSensitivity::CaseSensitive));
EXPECT(!AK::StringUtils::starts_with(test_string, "BCDEF", CaseSensitivity::CaseSensitive)); EXPECT(!AK::StringUtils::starts_with(test_string, "BCDEF", CaseSensitivity::CaseSensitive));
EXPECT(!AK::StringUtils::starts_with(test_string, "ABCDEFG", CaseSensitivity::CaseSensitive)); EXPECT(!AK::StringUtils::starts_with(test_string, "ABCDEFG", CaseSensitivity::CaseSensitive));
EXPECT(AK::StringUtils::starts_with(test_string, "abc", CaseSensitivity::CaseInsensitive)); EXPECT(AK::StringUtils::starts_with(test_string, "abc", CaseSensitivity::CaseInsensitive));
EXPECT(!AK::StringUtils::starts_with(test_string, "abc", CaseSensitivity::CaseSensitive)); EXPECT(!AK::StringUtils::starts_with(test_string, "abc", CaseSensitivity::CaseSensitive));
} }
TEST_MAIN(StringUtils) TEST_MAIN(StringUtils)

4
AK/Time.h
View file

@ -133,8 +133,8 @@ inline void timespec_add_timeval(const TimespecType& a, const TimevalType& b, Ti
template<typename TimevalType, typename TimespecType> template<typename TimevalType, typename TimespecType>
inline void timeval_to_timespec(const TimevalType& tv, TimespecType& ts) inline void timeval_to_timespec(const TimevalType& tv, TimespecType& ts)
{ {
ts.tv_sec = tv.tv_sec; ts.tv_sec = tv.tv_sec;
ts.tv_nsec = tv.tv_usec * 1000; ts.tv_nsec = tv.tv_usec * 1000;
} }
template<typename TimespecType, typename TimevalType> template<typename TimespecType, typename TimevalType>

4
AK/WeakPtr.h
View file

@ -39,8 +39,8 @@ class WeakPtr {
friend class Weakable<T>; friend class Weakable<T>;
public: public:
WeakPtr() {} WeakPtr() { }
WeakPtr(std::nullptr_t) {} WeakPtr(std::nullptr_t) { }
template<typename U> template<typename U>
WeakPtr(WeakPtr<U>&& other) WeakPtr(WeakPtr<U>&& other)