RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 05:57:45 +00:00
Code Issues Activity Actions

Everywhere: Run clang-format

Browse source
This commit is contained in:
Idan Horowitz 2022-04-01 20:58:27 +03:00 • committed by Linus Groh
parent 0376c127f6
commit 086969277e
1665 changed files with 8479 additions and 8479 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Tests/AK/TestArray.cpp
View file

@ -8,7 +8,7 @@
#include <AK/Array.h>
static constexpr int constexpr_sum(const Span<const int> span)
static constexpr int constexpr_sum(Span<int const> const span)
{
int sum = 0;
for (auto value : span)

4
Tests/AK/TestBase64.cpp
View file

@ -12,7 +12,7 @@
TEST_CASE(test_decode)
{
auto decode_equal = [&](const char* input, const char* expected) {
auto decode_equal = [&](char const* input, char const* expected) {
auto decoded_option = decode_base64(StringView(input));
EXPECT(!decoded_option.is_error());
auto decoded = decoded_option.release_value();
@ -41,7 +41,7 @@ TEST_CASE(test_decode_invalid)
TEST_CASE(test_encode)
{
auto encode_equal = [&](const char* input, const char* expected) {
auto encode_equal = [&](char const* input, char const* expected) {
auto encoded = encode_base64({ input, strlen(input) });
EXPECT(encoded == String(expected));
EXPECT_EQ(StringView(expected).length(), calculate_base64_encoded_length(StringView(input).bytes()));

4
Tests/AK/TestBinarySearch.cpp
View file

@ -54,7 +54,7 @@ TEST_CASE(vector_strings)
strings.append("cat");
strings.append("dog");
auto string_compare = [](const String& a, const String& b) -> int {
auto string_compare = [](String const& a, String const& b) -> int {
return strcmp(a.characters(), b.characters());
};
auto test1 = *binary_search(strings, String("bat"), nullptr, string_compare);
@ -108,7 +108,7 @@ TEST_CASE(constexpr_array_search)
TEST_CASE(unsigned_to_signed_regression)
{
const Array<u32, 5> input { 0, 1, 2, 3, 4 };
Array<u32, 5> const input { 0, 1, 2, 3, 4 };
// The algorithm computes 1 - input[2] = -1, and if this is (incorrectly) cast
// to an unsigned then it will look in the wrong direction and miss the 1.

2
Tests/AK/TestBitmap.cpp
View file

@ -216,7 +216,7 @@ TEST_CASE(count_in_range)
bitmap.set(i, true);
}
auto count_bits_slow = [](const Bitmap& b, size_t start, size_t len, bool value) -> size_t {
auto count_bits_slow = [](Bitmap const& b, size_t start, size_t len, bool value) -> size_t {
size_t count = 0;
for (size_t i = start; i < start + len; i++) {
if (b.get(i) == value)

2
Tests/AK/TestDoublyLinkedList.cpp
View file

@ -35,7 +35,7 @@ TEST_CASE(should_find_mutable)
TEST_CASE(should_find_const)
{
const auto sut = make_list();
auto const sut = make_list();
EXPECT_EQ(4, *sut.find(4));

6
Tests/AK/TestFormat.cpp
View file

@ -14,7 +14,7 @@
TEST_CASE(is_integral_works_properly)
{
EXPECT(!IsIntegral<const char*>);
EXPECT(!IsIntegral<char const*>);
EXPECT(IsIntegral<unsigned long>);
}
@ -186,7 +186,7 @@ TEST_CASE(ensure_that_format_works)
TEST_CASE(format_string_literal_as_pointer)
{
const char* literal = "abc";
char const* literal = "abc";
EXPECT_EQ(String::formatted("{:p}", literal), String::formatted("{:p}", reinterpret_cast<FlatPtr>(literal)));
}
@ -228,7 +228,7 @@ TEST_CASE(file_descriptor)
rewind(file);
Array<u8, 256> buffer;
const auto nread = fread(buffer.data(), 1, buffer.size(), file);
auto const nread = fread(buffer.data(), 1, buffer.size(), file);
EXPECT_EQ("Hello, World!\nfoobar\n"sv, StringView { buffer.span().trim(nread) });

8
Tests/AK/TestHashFunctions.cpp
View file

@ -42,14 +42,14 @@ TEST_CASE(ptr_hash)
EXPECT_EQ(ptr_hash(FlatPtr(42)), 2824066580u);
EXPECT_EQ(ptr_hash(FlatPtr(0)), 954888656u);
EXPECT_EQ(ptr_hash(reinterpret_cast<const void*>(42)), 2824066580u);
EXPECT_EQ(ptr_hash(reinterpret_cast<const void*>(0)), 954888656u);
EXPECT_EQ(ptr_hash(reinterpret_cast<void const*>(42)), 2824066580u);
EXPECT_EQ(ptr_hash(reinterpret_cast<void const*>(0)), 954888656u);
} else {
EXPECT_EQ(ptr_hash(FlatPtr(42)), 3564735745u);
EXPECT_EQ(ptr_hash(FlatPtr(0)), 1177991625u);
EXPECT_EQ(ptr_hash(reinterpret_cast<const void*>(42)), 3564735745u);
EXPECT_EQ(ptr_hash(reinterpret_cast<const void*>(0)), 1177991625u);
EXPECT_EQ(ptr_hash(reinterpret_cast<void const*>(42)), 3564735745u);
EXPECT_EQ(ptr_hash(reinterpret_cast<void const*>(0)), 1177991625u);
}
}

2
Tests/AK/TestHashMap.cpp
View file

@ -111,7 +111,7 @@ TEST_CASE(case_insensitive)
TEST_CASE(hashmap_of_nonnullownptr_get)
{
struct Object {
Object(const String& s)
Object(String const& s)
: string(s)
{
}

4
Tests/AK/TestHashTable.cpp
View file

@ -136,7 +136,7 @@ TEST_CASE(many_strings)
TEST_CASE(many_collisions)
{
struct StringCollisionTraits : public GenericTraits<String> {
static unsigned hash(const String&) { return 0; }
static unsigned hash(String const&) { return 0; }
};
HashTable<String, StringCollisionTraits> strings;
@ -158,7 +158,7 @@ TEST_CASE(many_collisions)
TEST_CASE(space_reuse)
{
struct StringCollisionTraits : public GenericTraits<String> {
static unsigned hash(const String&) { return 0; }
static unsigned hash(String const&) { return 0; }
};
HashTable<String, StringCollisionTraits> strings;

12
Tests/AK/TestIPv4Address.cpp
View file

@ -66,7 +66,7 @@ TEST_CASE(should_convert_to_string)
TEST_CASE(should_make_ipv4_address_from_string)
{
const auto addr = IPv4Address::from_string("192.168.0.1");
auto const addr = IPv4Address::from_string("192.168.0.1");
EXPECT(addr.has_value());
EXPECT_EQ(192, addr.value()[0]);
@ -77,21 +77,21 @@ TEST_CASE(should_make_ipv4_address_from_string)
TEST_CASE(should_make_empty_optional_from_bad_string)
{
const auto addr = IPv4Address::from_string("bad string");
auto const addr = IPv4Address::from_string("bad string");
EXPECT(!addr.has_value());
}
TEST_CASE(should_make_empty_optional_from_out_of_range_values)
{
const auto addr = IPv4Address::from_string("192.168.0.500");
auto const addr = IPv4Address::from_string("192.168.0.500");
EXPECT(!addr.has_value());
}
TEST_CASE(should_fill_d_octet_from_1_part)
{
const auto addr = IPv4Address::from_string("1");
auto const addr = IPv4Address::from_string("1");
EXPECT(addr.has_value());
EXPECT_EQ(0, addr.value()[0]);
@ -102,7 +102,7 @@ TEST_CASE(should_fill_d_octet_from_1_part)
TEST_CASE(should_fill_a_and_d_octets_from_2_parts)
{
const auto addr = IPv4Address::from_string("192.1");
auto const addr = IPv4Address::from_string("192.1");
EXPECT(addr.has_value());
EXPECT_EQ(192, addr.value()[0]);
@ -113,7 +113,7 @@ TEST_CASE(should_fill_a_and_d_octets_from_2_parts)
TEST_CASE(should_fill_a_b_d_octets_from_3_parts)
{
const auto addr = IPv4Address::from_string("192.168.1");
auto const addr = IPv4Address::from_string("192.168.1");
EXPECT(addr.has_value());
EXPECT_EQ(192, addr.value()[0]);

4
Tests/AK/TestJSON.cpp
View file

@ -46,7 +46,7 @@ TEST_CASE(load_form)
auto widgets = form_json.as_object().get("widgets").as_array();
widgets.for_each([&](const JsonValue& widget_value) {
widgets.for_each([&](JsonValue const& widget_value) {
auto& widget_object = widget_value.as_object();
auto widget_class = widget_object.get("class").as_string();
widget_object.for_each_member([&]([[maybe_unused]] auto& property_name, [[maybe_unused]] const JsonValue& property_value) {
@ -87,7 +87,7 @@ TEST_CASE(json_utf8_multibyte)
{
auto json_or_error = JsonValue::from_string("\"š\"");
EXPECT_EQ(json_or_error.is_error(), false);
auto& json = json_or_error.value();
EXPECT_EQ(json.type(), JsonValue::Type::String);
EXPECT_EQ(json.as_string().is_null(), false);

8
Tests/AK/TestMACAddress.cpp
View file

@ -85,7 +85,7 @@ TEST_CASE(should_string_format)
TEST_CASE(should_make_mac_address_from_string_numbers)
{
const auto sut = MACAddress::from_string("01:02:03:04:05:06");
auto const sut = MACAddress::from_string("01:02:03:04:05:06");
EXPECT(sut.has_value());
EXPECT_EQ(1, sut.value()[0]);
@ -98,7 +98,7 @@ TEST_CASE(should_make_mac_address_from_string_numbers)
TEST_CASE(should_make_mac_address_from_string_letters)
{
const auto sut = MACAddress::from_string("de:ad:be:ee:ee:ef");
auto const sut = MACAddress::from_string("de:ad:be:ee:ee:ef");
EXPECT(sut.has_value());
EXPECT_EQ(u8 { 0xDE }, sut.value()[0]);
@ -111,14 +111,14 @@ TEST_CASE(should_make_mac_address_from_string_letters)
TEST_CASE(should_make_empty_optional_from_bad_string)
{
const auto sut = MACAddress::from_string("bad string");
auto const sut = MACAddress::from_string("bad string");
EXPECT(!sut.has_value());
}
TEST_CASE(should_make_empty_optional_from_out_of_range_values)
{
const auto sut = MACAddress::from_string("de:ad:be:ee:ee:fz");
auto const sut = MACAddress::from_string("de:ad:be:ee:ee:fz");
EXPECT(!sut.has_value());
}

14
Tests/AK/TestMemoryStream.cpp
View file

@ -63,7 +63,7 @@ TEST_CASE(recoverable_error)
TEST_CASE(chain_stream_operator)
{
const Array<u8, 4> expected { 0, 1, 2, 3 };
Array<u8, 4> const expected { 0, 1, 2, 3 };
Array<u8, 4> actual;
InputMemoryStream stream { expected };
@ -76,10 +76,10 @@ TEST_CASE(chain_stream_operator)
TEST_CASE(seeking_slicing_offset)
{
const Array<u8, 8> input { 0, 1, 2, 3, 4, 5, 6, 7 };
const Array<u8, 4> expected0 { 0, 1, 2, 3 };
const Array<u8, 4> expected1 { 4, 5, 6, 7 };
const Array<u8, 4> expected2 { 1, 2, 3, 4 };
Array<u8, 8> const input { 0, 1, 2, 3, 4, 5, 6, 7 };
Array<u8, 4> const expected0 { 0, 1, 2, 3 };
Array<u8, 4> const expected1 { 4, 5, 6, 7 };
Array<u8, 4> const expected2 { 1, 2, 3, 4 };
Array<u8, 4> actual0 {}, actual1 {}, actual2 {};
@ -140,7 +140,7 @@ TEST_CASE(duplex_large_buffer)
TEST_CASE(read_endian_values)
{
const Array<u8, 8> input { 0, 1, 2, 3, 4, 5, 6, 7 };
Array<u8, 8> const input { 0, 1, 2, 3, 4, 5, 6, 7 };
InputMemoryStream stream { input };
LittleEndian<u32> value1;
@ -153,7 +153,7 @@ TEST_CASE(read_endian_values)
TEST_CASE(write_endian_values)
{
const Array<u8, 8> expected { 4, 3, 2, 1, 1, 2, 3, 4 };
Array<u8, 8> const expected { 4, 3, 2, 1, 1, 2, 3, 4 };
DuplexMemoryStream stream;
stream << LittleEndian<u32> { 0x01020304 } << BigEndian<u32> { 0x01020304 };

2
Tests/AK/TestNeverDestroyed.cpp
View file

@ -14,7 +14,7 @@ struct Counter {
~Counter() { ++num_destroys; }
Counter(const Counter&)
Counter(Counter const&)
{
++num_copies;
}

4
Tests/AK/TestOptional.cpp
View file

@ -159,7 +159,7 @@ TEST_CASE(test_copy_ctor_and_dtor_called)
{
}
CopyChecker(const CopyChecker& other)
CopyChecker(CopyChecker const& other)
: m_was_copy_constructed(other.m_was_copy_constructed)
{
m_was_copy_constructed = true;
@ -182,7 +182,7 @@ TEST_CASE(test_copy_ctor_and_dtor_called)
{
}
MoveChecker(const MoveChecker& other)
MoveChecker(MoveChecker const& other)
: m_was_move_constructed(other.m_was_move_constructed)
{
EXPECT(false);

4
Tests/AK/TestQuickSort.cpp
View file

@ -50,7 +50,7 @@ TEST_CASE(sorts_without_copy)
// So it provides no strong guarantees about the properties of quick_sort.
TEST_CASE(maximum_stack_depth)
{
const int size = 256;
int const size = 256;
int* data = new int[size];
for (int i = 0; i < size; i++) {
@ -72,7 +72,7 @@ TEST_CASE(maximum_stack_depth)
: max_depth(max_depth)
{
}
DepthMeasurer(const DepthMeasurer& obj)
DepthMeasurer(DepthMeasurer const& obj)
: max_depth(obj.max_depth)
{
depth = obj.depth + 1;

12
Tests/AK/TestSinglyLinkedList.cpp
View file

@ -37,14 +37,14 @@ TEST_CASE(should_find_mutable_with_predicate)
{
auto sut = make_list();
EXPECT_EQ(4, *sut.find_if([](const auto v) { return v == 4; }));
EXPECT_EQ(4, *sut.find_if([](auto const v) { return v == 4; }));
EXPECT_EQ(sut.end(), sut.find_if([](const auto v) { return v == 42; }));
EXPECT_EQ(sut.end(), sut.find_if([](auto const v) { return v == 42; }));
}
TEST_CASE(should_find_const)
{
const auto sut = make_list();
auto const sut = make_list();
EXPECT_EQ(4, *sut.find(4));
@ -53,11 +53,11 @@ TEST_CASE(should_find_const)
TEST_CASE(should_find_const_with_predicate)
{
const auto sut = make_list();
auto const sut = make_list();
EXPECT_EQ(4, *sut.find_if([](const auto v) { return v == 4; }));
EXPECT_EQ(4, *sut.find_if([](auto const v) { return v == 4; }));
EXPECT_EQ(sut.end(), sut.find_if([](const auto v) { return v == 42; }));
EXPECT_EQ(sut.end(), sut.find_if([](auto const v) { return v == 42; }));
}
TEST_CASE(removal_during_iteration)

2
Tests/AK/TestSourceLocation.cpp
View file

@ -18,7 +18,7 @@ TEST_CASE(basic_scenario)
EXPECT_EQ(StringView(__FILE__), location.filename());
}
static StringView test_default_arg(const SourceLocation& loc = SourceLocation::current())
static StringView test_default_arg(SourceLocation const& loc = SourceLocation::current())
{
return loc.function_name();
}

10
Tests/AK/TestSpan.cpp
View file

@ -115,23 +115,23 @@ TEST_CASE(span_from_void_pointer)
{
int value = 0;
[[maybe_unused]] Bytes bytes0 { reinterpret_cast<void*>(value), 4 };
[[maybe_unused]] ReadonlyBytes bytes1 { reinterpret_cast<const void*>(value), 4 };
[[maybe_unused]] ReadonlyBytes bytes1 { reinterpret_cast<void const*>(value), 4 };
}
TEST_CASE(span_from_c_string)
{
const char* str = "Serenity";
char const* str = "Serenity";
[[maybe_unused]] ReadonlyBytes bytes { str, strlen(str) };
}
TEST_CASE(starts_with)
{
const char* str = "HeyFriends!";
char const* str = "HeyFriends!";
ReadonlyBytes bytes { str, strlen(str) };
const char* str_hey = "Hey";
char const* str_hey = "Hey";
ReadonlyBytes hey_bytes { str_hey, strlen(str_hey) };
EXPECT(bytes.starts_with(hey_bytes));
const char* str_nah = "Nah";
char const* str_nah = "Nah";
ReadonlyBytes nah_bytes { str_nah, strlen(str_nah) };
EXPECT(!bytes.starts_with(nah_bytes));

2
Tests/AK/TestStringView.cpp
View file

@ -19,7 +19,7 @@ TEST_CASE(construct_empty)
TEST_CASE(view_literal)
{
const char* truth = "cats rule dogs drool";
char const* truth = "cats rule dogs drool";
StringView view(truth);
EXPECT_EQ(view.is_null(), false);
EXPECT_EQ(view.characters_without_null_termination(), truth);

4
Tests/AK/TestTuple.cpp
View file

@ -97,8 +97,8 @@ TEST_CASE(apply)
// With const reference, taken from a const tuple
{
bool was_called = false;
const auto& args_ref = args;
args_ref.apply_as_args([&](const int& a, const int& b, const String& c) {
auto const& args_ref = args;
args_ref.apply_as_args([&](int const& a, int const& b, String const& c) {
was_called = true;
EXPECT_EQ(a, 1);
EXPECT_EQ(b, 2);

2
Tests/AK/TestTypeTraits.cpp
View file

@ -220,7 +220,7 @@ TEST_CASE(IsConstructible)
};
EXPECT_VARIADIC_TRAIT_TRUE(IsConstructible, D, int);
EXPECT_VARIADIC_TRAIT_TRUE(IsConstructible, D, char);
EXPECT_VARIADIC_TRAIT_FALSE(IsConstructible, D, const char*);
EXPECT_VARIADIC_TRAIT_FALSE(IsConstructible, D, char const*);
EXPECT_VARIADIC_TRAIT_FALSE(IsConstructible, D, void);
}

4
Tests/AK/TestTypedTransfer.cpp
View file

@ -20,7 +20,7 @@ struct NonPrimitiveIntWrapper {
TEST_CASE(overlapping_source_and_destination_1)
{
const Array<NonPrimitiveIntWrapper, 6> expected { 3, 4, 5, 6, 5, 6 };
Array<NonPrimitiveIntWrapper, 6> const expected { 3, 4, 5, 6, 5, 6 };
Array<NonPrimitiveIntWrapper, 6> actual { 1, 2, 3, 4, 5, 6 };
AK::TypedTransfer<NonPrimitiveIntWrapper>::copy(actual.data(), actual.data() + 2, 4);
@ -31,7 +31,7 @@ TEST_CASE(overlapping_source_and_destination_1)
TEST_CASE(overlapping_source_and_destination_2)
{
const Array<NonPrimitiveIntWrapper, 6> expected { 1, 2, 1, 2, 3, 4 };
Array<NonPrimitiveIntWrapper, 6> const expected { 1, 2, 1, 2, 3, 4 };
Array<NonPrimitiveIntWrapper, 6> actual { 1, 2, 3, 4, 5, 6 };
AK::TypedTransfer<NonPrimitiveIntWrapper>::copy(actual.data() + 2, actual.data(), 4);

14
Tests/AK/TestVector.cpp
View file

@ -43,14 +43,14 @@ TEST_CASE(strings)
strings.append("DEF");
int loop_counter = 0;
for (const String& string : strings) {
for (String const& string : strings) {
EXPECT(!string.is_null());
EXPECT(!string.is_empty());
++loop_counter;
}
loop_counter = 0;
for (auto& string : (const_cast<const Vector<String>&>(strings))) {
for (auto& string : (const_cast<Vector<String> const&>(strings))) {
EXPECT(!string.is_null());
EXPECT(!string.is_empty());
++loop_counter;
@ -402,7 +402,7 @@ TEST_CASE(should_find_value)
{
Vector<int> v { 1, 2, 3, 4, 0, 6, 7, 8, 0, 0 };
const auto expected = v.begin() + 4;
auto const expected = v.begin() + 4;
EXPECT_EQ(expected, v.find(0));
}
@ -411,9 +411,9 @@ TEST_CASE(should_find_predicate)
{
Vector<int> v { 1, 2, 3, 4, 0, 6, 7, 8, 0, 0 };
const auto expected = v.begin() + 4;
auto const expected = v.begin() + 4;
EXPECT_EQ(expected, v.find_if([](const auto v) { return v == 0; }));
EXPECT_EQ(expected, v.find_if([](auto const v) { return v == 0; }));
}
TEST_CASE(should_find_index)
@ -548,8 +548,8 @@ TEST_CASE(rend)
{
Vector<int> v { 1, 2, 3, 4, 5, 6, 7, 8, 0 };
const auto expected = v.end() - 5;
const auto expected_in_reverse = v.rend() - 5;
auto const expected = v.end() - 5;
auto const expected_in_reverse = v.rend() - 5;
EXPECT_EQ(*expected, *expected_in_reverse);
}

2
Tests/Kernel/TestKernelPledge.cpp
View file

@ -18,7 +18,7 @@ TEST_CASE(test_nonexistent_pledge)
TEST_CASE(test_pledge_argument_validation)
{
const auto long_argument = String::repeated('a', 2048);
auto const long_argument = String::repeated('a', 2048);
auto res = pledge(long_argument.characters(), "stdio");
EXPECT_EQ(res, -1);

2
Tests/Kernel/bind-local-socket-to-symlink.cpp
View file

@ -13,7 +13,7 @@
int main(int, char**)
{
constexpr const char* path = "/tmp/foo";
constexpr char const* path = "/tmp/foo";
int rc = symlink("bar", path);
if (rc < 0) {
perror("symlink");

2
Tests/Kernel/elf-execve-mmap-race.cpp
View file

@ -16,7 +16,7 @@
#include <sys/wait.h>
#include <unistd.h>
volatile bool hax = false;
bool volatile hax = false;
int main()
{

8
Tests/Kernel/fuzz-syscalls.cpp
View file

@ -32,7 +32,7 @@ static bool is_nosys_syscall(int fn)
return fn == SC_futex || fn == SC_emuctl;
}
static bool is_bad_idea(int fn, const size_t* direct_sc_args, const size_t* fake_sc_params, const char* some_string)
static bool is_bad_idea(int fn, size_t const* direct_sc_args, size_t const* fake_sc_params, char const* some_string)
{
switch (fn) {
case SC_mprotect:
@ -78,7 +78,7 @@ static void do_systematic_tests()
VERIFY(rc == -ENOSYS);
}
static void randomize_from(size_t* buffer, size_t len, const Vector<size_t>& values)
static void randomize_from(size_t* buffer, size_t len, Vector<size_t> const& values)
{
for (size_t i = 0; i < len; ++i) {
buffer[i] = values[get_random_uniform(values.size())];
@ -122,7 +122,7 @@ static void do_random_tests()
size_t direct_sc_args[3] = { 0 };
// Isolate to a separate region to make corruption less likely, because we will write to it:
auto* fake_sc_params = reinterpret_cast<size_t*>(mmap(nullptr, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_RANDOMIZED, 0, 0));
const char* some_string = "Hello, world!";
char const* some_string = "Hello, world!";
Vector<size_t> interesting_values = {
0,
1,
@ -134,7 +134,7 @@ static void do_random_tests()
0xffffffff,
};
dbgln("Doing a few random syscalls with:");
for (const auto& interesting_value : interesting_values) {
for (auto const& interesting_value : interesting_values) {
dbgln(" {0} ({0:p})", interesting_value);
}
for (size_t i = 0; i < fuzz_syscall_count; ++i) {

4
Tests/Kernel/kill-pidtid-confusion.cpp
View file

@ -55,7 +55,7 @@ static void fork_into(void(fn)())
static void thread_into(void* (*fn)(void*))
{
pthread_t tid;
const int rc = pthread_create(&tid, nullptr, fn, nullptr);
int const rc = pthread_create(&tid, nullptr, fn, nullptr);
if (rc < 0) {
perror("pthread_create");
exit(1);
@ -64,7 +64,7 @@ static void thread_into(void* (*fn)(void*))
static void sleep_steps(useconds_t steps)
{
const int rc = usleep(steps * STEP_SIZE);
int const rc = usleep(steps * STEP_SIZE);
if (rc < 0) {
perror("usleep");
VERIFY_NOT_REACHED();

2
Tests/Kernel/mprotect-multi-region-mprotect.cpp
View file

@ -67,7 +67,7 @@ int main()
return 1;
}
//cleanup
// cleanup
munmap(map1, 6 * PAGE_SIZE);
outln("PASS");

2
Tests/Kernel/nanosleep-race-outbuf-munmap.cpp
View file

@ -19,7 +19,7 @@ static void signal_printer(int)
typedef struct yank_shared_t {
timespec* remaining_sleep;
// TODO: Be nice and use thread ID
//pthread_t sleeper_thread;
// pthread_t sleeper_thread;
} yank_shared_t;
static void* yanker_fn(void* shared_)

4
Tests/Kernel/pthread-cond-timedwait-example.cpp
View file

@ -14,7 +14,7 @@
#include <unistd.h>
struct worker_t {
const char* name;
char const* name;
int count;
pthread_t thread;
pthread_mutex_t lock;
@ -45,7 +45,7 @@ static void* run_worker(void* args)
return nullptr;
}
static void init_worker(worker_t* worker, const char* name, long int wait_time)
static void init_worker(worker_t* worker, char const* name, long int wait_time)
{
worker->name = name;
worker->wait_time = wait_time;

4
Tests/Kernel/setpgid-across-sessions-without-leader.cpp
View file

@ -57,7 +57,7 @@ static void fork_into(void (*fn)(void*), void* arg)
exit(1);
}
if (rc > 0) {
const int disown_rc = disown(rc);
int const disown_rc = disown(rc);
if (disown_rc < 0) {
perror("disown");
dbgln("This might cause PA1 to remain in the Zombie state, "
@ -73,7 +73,7 @@ static void fork_into(void (*fn)(void*), void* arg)
static void sleep_steps(useconds_t steps)
{
const int rc = usleep(steps * STEP_SIZE);
int const rc = usleep(steps * STEP_SIZE);
if (rc < 0) {
perror("usleep");
VERIFY_NOT_REACHED();

2
Tests/Kernel/siginfo-example.cpp
View file

@ -17,7 +17,7 @@ volatile ucontext_t saved_ucontext;
siginfo_t* sig_info_addr;
ucontext_t* ucontext_addr;
void* stack_ptr;
volatile bool signal_was_delivered = false;
bool volatile signal_was_delivered = false;
static void signal_handler(int sig, siginfo_t* sig_info, void* u_context)
{

2
Tests/Kernel/stress-truncate.cpp
View file

@ -13,7 +13,7 @@
int main(int argc, char** argv)
{
const char* target = nullptr;
char const* target = nullptr;
int max_file_size = 1024 * 1024;
int count = 1024;

2
Tests/Kernel/stress-writeread.cpp
View file

@ -60,7 +60,7 @@ bool write_block(int fd, int seed, off_t block, AK::ByteBuffer& buffer)
int main(int argc, char** argv)
{
const char* target = nullptr;
char const* target = nullptr;
int min_block_offset = 0;
int block_length = 2048;
int block_size = 512;

4
Tests/LibC/TestIo.cpp
View file

@ -348,9 +348,9 @@ TEST_CASE(writev)
EXPECT(rc == 0);
iovec iov[2];
iov[0].iov_base = const_cast<void*>((const void*)"Hello");
iov[0].iov_base = const_cast<void*>((void const*)"Hello");
iov[0].iov_len = 5;
iov[1].iov_base = const_cast<void*>((const void*)"Friends");
iov[1].iov_base = const_cast<void*>((void const*)"Friends");
iov[1].iov_len = 7;
int nwritten = writev(pipefds[1], iov, 2);
EXPECT_EQ(nwritten, 12);

6
Tests/LibC/TestLibCMkTemp.cpp
View file

@ -33,7 +33,7 @@ TEST_CASE(test_mktemp_unique_filename)
} else {
wait(NULL);
auto path1 = String::formatted("{}", reinterpret_cast<const char*>(ptr));
auto path1 = String::formatted("{}", reinterpret_cast<char const*>(ptr));
char path[] = "/tmp/test.mktemp.XXXXXX";
auto path2 = String::formatted("{}", mktemp(path));
@ -63,7 +63,7 @@ TEST_CASE(test_mkdtemp_unique_filename)
} else {
wait(NULL);
auto path1 = String::formatted("{}", reinterpret_cast<const char*>(ptr));
auto path1 = String::formatted("{}", reinterpret_cast<char const*>(ptr));
char path[] = "/tmp/test.mkdtemp.XXXXXX";
auto path2 = String::formatted("{}", mkdtemp(path));
@ -101,7 +101,7 @@ TEST_CASE(test_mkstemp_unique_filename)
} else {
wait(NULL);
auto path1 = String::formatted("{}", reinterpret_cast<const char*>(ptr));
auto path1 = String::formatted("{}", reinterpret_cast<char const*>(ptr));
char path[] = "/tmp/test.mkstemp.XXXXXX";
auto fd = mkstemp(path);

12
Tests/LibC/TestLibCSetjmp.cpp
View file

@ -12,7 +12,7 @@
TEST_CASE(setjmp)
{
jmp_buf env;
volatile int set = 1;
int volatile set = 1;
if (setjmp(env)) {
EXPECT_EQ(set, 0);
@ -29,7 +29,7 @@ TEST_CASE(setjmp)
TEST_CASE(setjmp_zero)
{
jmp_buf env;
volatile int set = 1;
int volatile set = 1;
switch (setjmp(env)) {
case 0:
@ -50,7 +50,7 @@ TEST_CASE(setjmp_zero)
TEST_CASE(setjmp_value)
{
jmp_buf env;
volatile int set = 1;
int volatile set = 1;
switch (setjmp(env)) {
case 0:
@ -71,7 +71,7 @@ TEST_CASE(setjmp_value)
TEST_CASE(sigsetjmp)
{
sigjmp_buf env;
volatile int set = 1;
int volatile set = 1;
if (sigsetjmp(env, 0)) {
EXPECT_EQ(set, 0);
@ -88,7 +88,7 @@ TEST_CASE(sigsetjmp)
TEST_CASE(sigsetjmp_zero)
{
sigjmp_buf env;
volatile int set = 1;
int volatile set = 1;
switch (sigsetjmp(env, 0)) {
case 0:
@ -109,7 +109,7 @@ TEST_CASE(sigsetjmp_zero)
TEST_CASE(sigsetjmp_value)
{
sigjmp_buf env;
volatile int set = 1;
int volatile set = 1;
switch (sigsetjmp(env, 0)) {
case 0:

2
Tests/LibC/TestLibCTime.cpp
View file

@ -8,7 +8,7 @@
#include <LibTest/TestCase.h>
#include <time.h>
const auto expected_epoch = "Thu Jan 1 00:00:00 1970\n"sv;
auto const expected_epoch = "Thu Jan 1 00:00:00 1970\n"sv;
class TimeZoneGuard {
public:

12
Tests/LibC/TestMemmem.cpp
View file

@ -10,19 +10,19 @@
#include <string.h>
struct TestCase {
const u8* haystack;
u8 const* haystack;
size_t haystack_length;
const u8* needle;
u8 const* needle;
size_t needle_length;
ssize_t matching_offset { -1 };
};
const static TestCase g_test_cases[] = {
{ (const u8*) {}, 0u, (const u8*) {}, 0u, 0 },
{ (u8 const*) {}, 0u, (u8 const*) {}, 0u, 0 },
{ (const u8[]) { 1, 2, 3 }, 3u, (const u8[]) { 1, 2, 3 }, 3u, 0 },
{ (const u8[]) { 1, 2, 4 }, 3u, (const u8[]) { 1, 2, 3 }, 3u, -1 },
{ (const u8*)"abcdef", 6u, (const u8[]) {}, 0u, 0 },
{ (const u8*)"abcdef", 6u, (const u8*)"de", 2u, 3 },
{ (u8 const*)"abcdef", 6u, (const u8[]) {}, 0u, 0 },
{ (u8 const*)"abcdef", 6u, (u8 const*)"de", 2u, 3 },
{ (const u8[]) { 0, 1, 2, 5, 2, 5 }, 6u, (const u8[]) { 1 }, 1u, 1 },
{ (const u8[]) { 0, 1, 2, 5, 2, 5 }, 6u, (const u8[]) { 1, 2 }, 2u, 1 },
{ (const u8[]) { 0, 1, 1, 2 }, 4u, (const u8[]) { 1, 5 }, 2u, -1 },
@ -33,7 +33,7 @@ const static TestCase g_test_cases[] = {
TEST_CASE(memmem_search)
{
size_t i = 0;
for (const auto& test_case : g_test_cases) {
for (auto const& test_case : g_test_cases) {
auto expected = test_case.matching_offset >= 0 ? test_case.haystack + test_case.matching_offset : nullptr;
auto result = memmem(test_case.haystack, test_case.haystack_length, test_case.needle, test_case.needle_length);
if (result != expected) {

14
Tests/LibC/TestQsort.cpp
View file

@ -19,10 +19,10 @@ struct SortableObject {
int m_payload;
};
static int compare_sortable_object(const void* a, const void* b)
static int compare_sortable_object(void const* a, void const* b)
{
const int key1 = static_cast<const SortableObject*>(a)->m_key;
const int key2 = static_cast<const SortableObject*>(b)->m_key;
int const key1 = static_cast<SortableObject const*>(a)->m_key;
int const key2 = static_cast<SortableObject const*>(b)->m_key;
if (key1 < key2) {
return -1;
} else if (key1 == key2) {
@ -60,16 +60,16 @@ TEST_CASE(quick_sort)
qsort(test_objects.data(), test_objects.size(), sizeof(SortableObject), compare_sortable_object);
// Check that the objects are sorted by key
for (auto i = 0u; i + 1 < test_objects.size(); ++i) {
const auto& key1 = test_objects[i].m_key;
const auto& key2 = test_objects[i + 1].m_key;
auto const& key1 = test_objects[i].m_key;
auto const& key2 = test_objects[i + 1].m_key;
if (key1 > key2) {
FAIL(String::formatted("saw key {} before key {}\n", key1, key2));
}
}
// Check that the object's payloads have not been corrupted
for (auto i = 0u; i < test_objects.size(); ++i) {
const auto expected = calc_payload_for_pos(i);
const auto payload = test_objects[i].m_payload;
auto const expected = calc_payload_for_pos(i);
auto const payload = test_objects[i].m_payload;
if (payload != expected) {
FAIL(String::formatted("Expected payload {} for pos {}, got payload {}", expected, i, payload));
}

2
Tests/LibC/TestRealpath.cpp
View file

@ -21,7 +21,7 @@ static constexpr char PATH_LOREM_250[] = "This-is-an-annoyingly-long-name-that-s
static constexpr size_t ITERATION_DEPTH = 17;
static void check_result(const char* what, const String& expected, const char* actual)
static void check_result(char const* what, String const& expected, char const* actual)
{
if (expected != actual)
FAIL(String::formatted("Expected {} to be \"{}\" ({} characters)", what, actual, actual ? strlen(actual) : 0));

16
Tests/LibC/TestScanf.cpp
View file

@ -65,7 +65,7 @@ constexpr static Array<unsigned char, 32> to_value_t(T x)
}
template<size_t N>
constexpr static Array<unsigned char, 32> str_to_value_t(const char (&x)[N])
constexpr static Array<unsigned char, 32> str_to_value_t(char const (&x)[N])
{
Array<unsigned char, 32> value { 0 };
for (size_t i = 0; i < N; ++i)
@ -78,7 +78,7 @@ struct Argument {
void* data;
};
static Array<u8, 32> arg_to_value_t(const Argument& arg)
static Array<u8, 32> arg_to_value_t(Argument const& arg)
{
if (arg.size == 1)
return to_value_t(*(u8*)arg.data);
@ -140,8 +140,8 @@ Argument charstararg1 { sizeof(charstar), &_charstararg1[0] };
Argument charstararg2 { sizeof(charstar), &_charstararg2[0] };
struct TestSuite {
const char* format;
const char* input;
char const* format;
char const* input;
int expected_return_value;
size_t argument_count;
Argument arguments[8];
@ -184,7 +184,7 @@ const TestSuite test_suites[] {
bool g_any_failed = false;
static bool check_value_conformance(const TestSuite& test)
static bool check_value_conformance(TestSuite const& test)
{
bool fail = false;
for (size_t i = 0; i < test.argument_count; ++i) {
@ -192,8 +192,8 @@ static bool check_value_conformance(const TestSuite& test)
auto arg_value = arg_to_value_t(arg);
auto& value = test.expected_values[i];
if (arg_value != value) {
auto arg_ptr = (const u32*)arg_value.data();
auto value_ptr = (const u32*)value.data();
auto arg_ptr = (u32 const*)arg_value.data();
auto value_ptr = (u32 const*)value.data();
printf(" value %zu FAIL,\n", i);
printf(" expected %08x%08x%08x%08x%08x%08x%08x%08x\n",
value_ptr[0], value_ptr[1], value_ptr[2], value_ptr[3],
@ -210,7 +210,7 @@ static bool check_value_conformance(const TestSuite& test)
return !fail;
}
static void do_one_test(const TestSuite& test)
static void do_one_test(TestSuite const& test)
{
printf("Testing '%s' against '%s'...\n", test.input, test.format);

10
Tests/LibC/TestSearch.cpp
View file

@ -13,11 +13,11 @@
#define NODE(node) static_cast<struct search_tree_node*>(node)
#define ROOTP(root) reinterpret_cast<void**>(root)
#define COMP(func) reinterpret_cast<int (*)(const void*, const void*)>(func)
#define COMP(func) reinterpret_cast<int (*)(void const*, void const*)>(func)
#define U8(value) static_cast<u8>(value)
struct twalk_test_entry {
const void* node;
void const* node;
VISIT order;
int depth;
};
@ -30,7 +30,7 @@ TEST_CASE(tsearch)
{
struct search_tree_node* root = nullptr;
void* ret;
const char* key;
char const* key;
char* search;
// Try a nullptr rootp.
@ -150,8 +150,8 @@ TEST_CASE(tfind)
delete_node_recursive(root);
}
void twalk_action(const void* node, VISIT order, int depth);
void twalk_action(const void* node, VISIT order, int depth)
void twalk_action(void const* node, VISIT order, int depth);
void twalk_action(void const* node, VISIT order, int depth)
{
static int count = 0;
static const struct twalk_test_entry* tests = nullptr;

48
Tests/LibC/TestSnprintf.cpp
View file

@ -18,16 +18,16 @@
template<typename TArg>
struct Testcase {
const char* dest;
char const* dest;
size_t dest_n;
const char* fmt;
char const* fmt;
const TArg arg;
int expected_return;
const char* dest_expected;
char const* dest_expected;
size_t dest_expected_n; // == dest_n
};
static String show(const ByteBuffer& buf)
static String show(ByteBuffer const& buf)
{
StringBuilder builder;
for (size_t i = 0; i < buf.size(); ++i) {
@ -46,7 +46,7 @@ static String show(const ByteBuffer& buf)
}
template<typename TArg>
static bool test_single(const Testcase<TArg>& testcase)
static bool test_single(Testcase<TArg> const& testcase)
{
constexpr size_t SANDBOX_CANARY_SIZE = 8;
@ -109,41 +109,41 @@ static bool test_single(const Testcase<TArg>& testcase)
// Drop the NUL terminator added by the C++ compiler.
#define LITERAL(x) x, (sizeof(x) - 1)
static const char* const POISON = (const char*)1;
static char const* const POISON = (char const*)1;
TEST_CASE(golden_path)
{
EXPECT(test_single<const char*>({ LITERAL("Hello World!\0\0\0"), "Hello Friend!", POISON, 13, LITERAL("Hello Friend!\0\0") }));
EXPECT(test_single<const char*>({ LITERAL("Hello World!\0\0\0"), "Hello %s!", "Friend", 13, LITERAL("Hello Friend!\0\0") }));
EXPECT(test_single<const char*>({ LITERAL("aaaaaaaaaa"), "whf", POISON, 3, LITERAL("whf\0aaaaaa") }));
EXPECT(test_single<const char*>({ LITERAL("aaaaaaaaaa"), "w%sf", "h", 3, LITERAL("whf\0aaaaaa") }));
EXPECT(test_single<char const*>({ LITERAL("Hello World!\0\0\0"), "Hello Friend!", POISON, 13, LITERAL("Hello Friend!\0\0") }));
EXPECT(test_single<char const*>({ LITERAL("Hello World!\0\0\0"), "Hello %s!", "Friend", 13, LITERAL("Hello Friend!\0\0") }));
EXPECT(test_single<char const*>({ LITERAL("aaaaaaaaaa"), "whf", POISON, 3, LITERAL("whf\0aaaaaa") }));
EXPECT(test_single<char const*>({ LITERAL("aaaaaaaaaa"), "w%sf", "h", 3, LITERAL("whf\0aaaaaa") }));
}
TEST_CASE(border_cases)
{
EXPECT(test_single<const char*>({ LITERAL("Hello World!\0\0"), "Hello Friend!", POISON, 13, LITERAL("Hello Friend!\0") }));
EXPECT(test_single<const char*>({ LITERAL("AAAA"), "whf", POISON, 3, LITERAL("whf\0") }));
EXPECT(test_single<const char*>({ LITERAL("AAAA"), "%s", "whf", 3, LITERAL("whf\0") }));
EXPECT(test_single<char const*>({ LITERAL("Hello World!\0\0"), "Hello Friend!", POISON, 13, LITERAL("Hello Friend!\0") }));
EXPECT(test_single<char const*>({ LITERAL("AAAA"), "whf", POISON, 3, LITERAL("whf\0") }));
EXPECT(test_single<char const*>({ LITERAL("AAAA"), "%s", "whf", 3, LITERAL("whf\0") }));
}
TEST_CASE(too_long)
{
EXPECT(test_single<const char*>({ LITERAL("Hello World!\0"), "Hello Friend!", POISON, 13, LITERAL("Hello Friend\0") }));
EXPECT(test_single<const char*>({ LITERAL("Hello World!\0"), "This source is %s too long!", "just *way*", 35, LITERAL("This source \0") }));
EXPECT(test_single<const char*>({ LITERAL("x"), "This source is %s too long!", "just *way*", 35, LITERAL("\0") }));
EXPECT(test_single<char const*>({ LITERAL("Hello World!\0"), "Hello Friend!", POISON, 13, LITERAL("Hello Friend\0") }));
EXPECT(test_single<char const*>({ LITERAL("Hello World!\0"), "This source is %s too long!", "just *way*", 35, LITERAL("This source \0") }));
EXPECT(test_single<char const*>({ LITERAL("x"), "This source is %s too long!", "just *way*", 35, LITERAL("\0") }));
}
TEST_CASE(special_cases)
{
EXPECT(test_single<const char*>({ LITERAL(""), "Hello Friend!", POISON, 13, LITERAL("") }));
EXPECT(test_single<char const*>({ LITERAL(""), "Hello Friend!", POISON, 13, LITERAL("") }));
EXPECT_EQ(snprintf(nullptr, 0, "Hello, friend!"), 14);
EXPECT(test_single<const char*>({ LITERAL(""), "", POISON, 0, LITERAL("") }));
EXPECT(test_single<const char*>({ LITERAL("x"), "", POISON, 0, LITERAL("\0") }));
EXPECT(test_single<const char*>({ LITERAL("xx"), "", POISON, 0, LITERAL("\0x") }));
EXPECT(test_single<const char*>({ LITERAL("xxx"), "", POISON, 0, LITERAL("\0xx") }));
EXPECT(test_single<const char*>({ LITERAL(""), "whf", POISON, 3, LITERAL("") }));
EXPECT(test_single<const char*>({ LITERAL("x"), "whf", POISON, 3, LITERAL("\0") }));
EXPECT(test_single<const char*>({ LITERAL("xx"), "whf", POISON, 3, LITERAL("w\0") }));
EXPECT(test_single<char const*>({ LITERAL(""), "", POISON, 0, LITERAL("") }));
EXPECT(test_single<char const*>({ LITERAL("x"), "", POISON, 0, LITERAL("\0") }));
EXPECT(test_single<char const*>({ LITERAL("xx"), "", POISON, 0, LITERAL("\0x") }));
EXPECT(test_single<char const*>({ LITERAL("xxx"), "", POISON, 0, LITERAL("\0xx") }));
EXPECT(test_single<char const*>({ LITERAL(""), "whf", POISON, 3, LITERAL("") }));
EXPECT(test_single<char const*>({ LITERAL("x"), "whf", POISON, 3, LITERAL("\0") }));
EXPECT(test_single<char const*>({ LITERAL("xx"), "whf", POISON, 3, LITERAL("w\0") }));
}
TEST_CASE(octal_values)

10
Tests/LibC/TestStrlcpy.cpp
View file

@ -14,15 +14,15 @@
#include <string.h>
struct Testcase {
const char* dest;
char const* dest;
size_t dest_n;
const char* src;
char const* src;
size_t src_n;
const char* dest_expected;
char const* dest_expected;
size_t dest_expected_n; // == dest_n
};
static String show(const ByteBuffer& buf)
static String show(ByteBuffer const& buf)
{
StringBuilder builder;
for (size_t i = 0; i < buf.size(); ++i) {
@ -40,7 +40,7 @@ static String show(const ByteBuffer& buf)
return builder.build();
}
static bool test_single(const Testcase& testcase)
static bool test_single(Testcase const& testcase)
{
constexpr size_t SANDBOX_CANARY_SIZE = 8;

14
Tests/LibC/TestStrtodAccuracy.cpp
View file

@ -18,10 +18,10 @@ static constexpr char TEXT_RESET[] = "\x1b[0m";
static constexpr long long LENIENCY = 8;
struct Testcase {
const char* test_name;
char const* test_name;
int should_consume;
const char* hex;
const char* test_string;
char const* hex;
char const* test_string;
};
static Testcase TESTCASES[] = {
@ -231,7 +231,7 @@ static Testcase TESTCASES[] = {
constexpr size_t NUM_TESTCASES = sizeof(TESTCASES) / sizeof(TESTCASES[0]);
typedef double (*strtod_fn_t)(const char* str, char** endptr);
typedef double (*strtod_fn_t)(char const* str, char** endptr);
static long long cast_ll(double d)
{
@ -250,7 +250,7 @@ static long long cast_ll(double d)
return readable.as_ll;
}
static bool is_strtod_close(strtod_fn_t strtod_fn, const char* test_string, const char* expect_hex, int expect_consume, long long expect_ll)
static bool is_strtod_close(strtod_fn_t strtod_fn, char const* test_string, char const* expect_hex, int expect_consume, long long expect_ll)
{
union readable_t {
double as_double;
@ -277,7 +277,7 @@ static bool is_strtod_close(strtod_fn_t strtod_fn, const char* test_string, cons
if (endptr < test_string) {
actual_consume = 999;
} else {
const char* max_endptr = test_string + strlen(test_string);
char const* max_endptr = test_string + strlen(test_string);
actual_consume_possible = endptr <= max_endptr;
actual_consume = endptr - test_string;
}
@ -303,7 +303,7 @@ static bool is_strtod_close(strtod_fn_t strtod_fn, const char* test_string, cons
return !(wrong_hex || error_cns || wrong_cns);
}
static long long hex_to_ll(const char* hex)
static long long hex_to_ll(char const* hex)
{
long long result = 0;
for (int i = 0; i < 16; ++i) {

24
Tests/LibC/TestWchar.cpp
View file

@ -13,7 +13,7 @@
TEST_CASE(wcspbrk)
{
const wchar_t* input;
wchar_t const* input;
wchar_t* ret;
// Test empty haystack.
@ -40,7 +40,7 @@ TEST_CASE(wcspbrk)
TEST_CASE(wcsstr)
{
const wchar_t* input = L"abcde";
wchar_t const* input = L"abcde";
wchar_t* ret;
// Empty needle should return haystack.
@ -70,7 +70,7 @@ TEST_CASE(wcsstr)
TEST_CASE(wmemchr)
{
const wchar_t* input = L"abcde";
wchar_t const* input = L"abcde";
wchar_t* ret;
// Empty haystack returns nothing.
@ -102,7 +102,7 @@ TEST_CASE(wmemchr)
TEST_CASE(wmemcpy)
{
const wchar_t* input = L"abc\0def";
wchar_t const* input = L"abc\0def";
auto buf = static_cast<wchar_t*>(malloc(8 * sizeof(wchar_t)));
if (!buf) {
@ -142,7 +142,7 @@ TEST_CASE(wmemset)
TEST_CASE(wmemmove)
{
wchar_t* ret;
const wchar_t* string = L"abc\0def";
wchar_t const* string = L"abc\0def";
auto buf = static_cast<wchar_t*>(calloc(32, sizeof(wchar_t)));
if (!buf) {
@ -324,7 +324,7 @@ TEST_CASE(wcsrtombs)
char buf[MB_LEN_MAX * 4];
const wchar_t good_chars[] = { L'\U0001F41E', L'\U0001F41E', L'\0' };
const wchar_t bad_chars[] = { L'\U0001F41E', static_cast<wchar_t>(0x1111F41E), L'\0' };
const wchar_t* src;
wchar_t const* src;
size_t ret = 0;
// Convert normal and valid wchar_t values.
@ -369,7 +369,7 @@ TEST_CASE(wcsnrtombs)
{
mbstate_t state = {};
const wchar_t good_chars[] = { L'\U0001F41E', L'\U0001F41E', L'\0' };
const wchar_t* src;
wchar_t const* src;
size_t ret = 0;
// Convert nothing.
@ -395,9 +395,9 @@ TEST_CASE(mbsrtowcs)
{
mbstate_t state = {};
wchar_t buf[4];
const char good_chars[] = "\xf0\x9f\x90\x9e\xf0\x9f\x90\x9e";
const char bad_chars[] = "\xf0\x9f\x90\x9e\xf0\xff\x90\x9e";
const char* src;
char const good_chars[] = "\xf0\x9f\x90\x9e\xf0\x9f\x90\x9e";
char const bad_chars[] = "\xf0\x9f\x90\x9e\xf0\xff\x90\x9e";
char const* src;
size_t ret = 0;
// Convert normal and valid multibyte sequences.
@ -445,8 +445,8 @@ TEST_CASE(mbsrtowcs)
TEST_CASE(mbsnrtowcs)
{
mbstate_t state = {};
const char good_chars[] = "\xf0\x9f\x90\x9e\xf0\x9f\x90\x9e";
const char* src;
char const good_chars[] = "\xf0\x9f\x90\x9e\xf0\x9f\x90\x9e";
char const* src;
size_t ret = 0;
// Convert nothing.

34
Tests/LibCompress/TestDeflate.cpp
View file

@ -14,19 +14,19 @@
TEST_CASE(canonical_code_simple)
{
const Array<u8, 32> code {
Array<u8, 32> const code {
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05
};
const Array<u8, 6> input {
Array<u8, 6> const input {
0x00, 0x42, 0x84, 0xa9, 0xb0, 0x15
};
const Array<u32, 9> output {
Array<u32, 9> const output {
0x00, 0x01, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d, 0x15
};
const auto huffman = Compress::CanonicalCode::from_bytes(code).value();
auto const huffman = Compress::CanonicalCode::from_bytes(code).value();
auto memory_stream = InputMemoryStream { input };
auto bit_stream = InputBitStream { memory_stream };
@ -36,17 +36,17 @@ TEST_CASE(canonical_code_simple)
TEST_CASE(canonical_code_complex)
{
const Array<u8, 6> code {
Array<u8, 6> const code {
0x03, 0x02, 0x03, 0x03, 0x02, 0x03
};
const Array<u8, 4> input {
Array<u8, 4> const input {
0xa1, 0xf3, 0xa1, 0xf3
};
const Array<u32, 12> output {
Array<u32, 12> const output {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05
};
const auto huffman = Compress::CanonicalCode::from_bytes(code).value();
auto const huffman = Compress::CanonicalCode::from_bytes(code).value();
auto memory_stream = InputMemoryStream { input };
auto bit_stream = InputBitStream { memory_stream };
@ -56,7 +56,7 @@ TEST_CASE(canonical_code_complex)
TEST_CASE(deflate_decompress_compressed_block)
{
const Array<u8, 28> compressed {
Array<u8, 28> const compressed {
0x0B, 0xC9, 0xC8, 0x2C, 0x56, 0x00, 0xA2, 0x44, 0x85, 0xE2, 0xCC, 0xDC,
0x82, 0x9C, 0x54, 0x85, 0x92, 0xD4, 0x8A, 0x12, 0x85, 0xB4, 0x4C, 0x20,
0xCB, 0x4A, 0x13, 0x00
@ -64,26 +64,26 @@ TEST_CASE(deflate_decompress_compressed_block)
const u8 uncompressed[] = "This is a simple text file :)";
const auto decompressed = Compress::DeflateDecompressor::decompress_all(compressed);
auto const decompressed = Compress::DeflateDecompressor::decompress_all(compressed);
EXPECT(decompressed.value().bytes() == ReadonlyBytes({ uncompressed, sizeof(uncompressed) - 1 }));
}
TEST_CASE(deflate_decompress_uncompressed_block)
{
const Array<u8, 18> compressed {
Array<u8, 18> const compressed {
0x01, 0x0d, 0x00, 0xf2, 0xff, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20,
0x57, 0x6f, 0x72, 0x6c, 0x64, 0x21
};
const u8 uncompressed[] = "Hello, World!";
const auto decompressed = Compress::DeflateDecompressor::decompress_all(compressed);
auto const decompressed = Compress::DeflateDecompressor::decompress_all(compressed);
EXPECT(decompressed.value().bytes() == (ReadonlyBytes { uncompressed, sizeof(uncompressed) - 1 }));
}
TEST_CASE(deflate_decompress_multiple_blocks)
{
const Array<u8, 84> compressed {
Array<u8, 84> const compressed {
0x00, 0x1f, 0x00, 0xe0, 0xff, 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72,
0x73, 0x74, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x69, 0x73, 0x20,
0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64,
@ -94,20 +94,20 @@ TEST_CASE(deflate_decompress_multiple_blocks)
const u8 uncompressed[] = "The first block is uncompressed and the second block is compressed.";
const auto decompressed = Compress::DeflateDecompressor::decompress_all(compressed);
auto const decompressed = Compress::DeflateDecompressor::decompress_all(compressed);
EXPECT(decompressed.value().bytes() == (ReadonlyBytes { uncompressed, sizeof(uncompressed) - 1 }));
}
TEST_CASE(deflate_decompress_zeroes)
{
const Array<u8, 20> compressed {
Array<u8, 20> const compressed {
0xed, 0xc1, 0x01, 0x0d, 0x00, 0x00, 0x00, 0xc2, 0xa0, 0xf7, 0x4f, 0x6d,
0x0f, 0x07, 0x14, 0x00, 0x00, 0x00, 0xf0, 0x6e
};
const Array<u8, 4096> uncompressed { 0 };
Array<u8, 4096> const uncompressed { 0 };
const auto decompressed = Compress::DeflateDecompressor::decompress_all(compressed);
auto const decompressed = Compress::DeflateDecompressor::decompress_all(compressed);
EXPECT(uncompressed == decompressed.value().bytes());
}

18
Tests/LibCompress/TestGzip.cpp
View file

@ -12,7 +12,7 @@
TEST_CASE(gzip_decompress_simple)
{
const Array<u8, 33> compressed {
Array<u8, 33> const compressed {
0x1f, 0x8b, 0x08, 0x00, 0x77, 0xff, 0x47, 0x5f, 0x02, 0xff, 0x2b, 0xcf,
0x2f, 0x4a, 0x31, 0x54, 0x48, 0x4c, 0x4a, 0x56, 0x28, 0x07, 0xb2, 0x8c,
0x00, 0xc2, 0x1d, 0x22, 0x15, 0x0f, 0x00, 0x00, 0x00
@ -20,13 +20,13 @@ TEST_CASE(gzip_decompress_simple)
const u8 uncompressed[] = "word1 abc word2";
const auto decompressed = Compress::GzipDecompressor::decompress_all(compressed);
auto const decompressed = Compress::GzipDecompressor::decompress_all(compressed);
EXPECT(decompressed.value().bytes() == (ReadonlyBytes { uncompressed, sizeof(uncompressed) - 1 }));
}
TEST_CASE(gzip_decompress_multiple_members)
{
const Array<u8, 52> compressed {
Array<u8, 52> const compressed {
0x1f, 0x8b, 0x08, 0x00, 0xe0, 0x03, 0x48, 0x5f, 0x02, 0xff, 0x4b, 0x4c,
0x4a, 0x4e, 0x4c, 0x4a, 0x06, 0x00, 0x4c, 0x99, 0x6e, 0x72, 0x06, 0x00,
0x00, 0x00, 0x1f, 0x8b, 0x08, 0x00, 0xe0, 0x03, 0x48, 0x5f, 0x02, 0xff,
@ -36,13 +36,13 @@ TEST_CASE(gzip_decompress_multiple_members)
const u8 uncompressed[] = "abcabcabcabc";
const auto decompressed = Compress::GzipDecompressor::decompress_all(compressed);
auto const decompressed = Compress::GzipDecompressor::decompress_all(compressed);
EXPECT(decompressed.value().bytes() == (ReadonlyBytes { uncompressed, sizeof(uncompressed) - 1 }));
}
TEST_CASE(gzip_decompress_zeroes)
{
const Array<u8, 161> compressed {
Array<u8, 161> const compressed {
0x1f, 0x8b, 0x08, 0x00, 0x6e, 0x7a, 0x4b, 0x5f, 0x02, 0xff, 0xed, 0xc1,
0x31, 0x01, 0x00, 0x00, 0x00, 0xc2, 0xa0, 0xf5, 0x4f, 0xed, 0x61, 0x0d,
0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -59,15 +59,15 @@ TEST_CASE(gzip_decompress_zeroes)
0x7e, 0x00, 0x00, 0x02, 0x00
};
const Array<u8, 128 * 1024> uncompressed = { 0 };
Array<u8, 128 * 1024> const uncompressed = { 0 };
const auto decompressed = Compress::GzipDecompressor::decompress_all(compressed);
auto const decompressed = Compress::GzipDecompressor::decompress_all(compressed);
EXPECT(uncompressed == decompressed.value().bytes());
}
TEST_CASE(gzip_decompress_repeat_around_buffer)
{
const Array<u8, 70> compressed {
Array<u8, 70> const compressed {
0x1f, 0x8b, 0x08, 0x00, 0xc6, 0x74, 0x53, 0x5f, 0x02, 0xff, 0xed, 0xc1,
0x01, 0x0d, 0x00, 0x00, 0x0c, 0x02, 0xa0, 0xdb, 0xbf, 0xf4, 0x37, 0x6b,
0x08, 0x24, 0xdb, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -81,7 +81,7 @@ TEST_CASE(gzip_decompress_repeat_around_buffer)
uncompressed.span().slice(0x0100, 0x7e00).fill(0);
uncompressed.span().slice(0x7f00, 0x0100).fill(1);
const auto decompressed = Compress::GzipDecompressor::decompress_all(compressed);
auto const decompressed = Compress::GzipDecompressor::decompress_all(compressed);
EXPECT(uncompressed == decompressed.value().bytes());
}

4
Tests/LibCompress/TestZlib.cpp
View file

@ -11,7 +11,7 @@
TEST_CASE(zlib_decompress_simple)
{
const Array<u8, 40> compressed {
Array<u8, 40> const compressed {
0x78, 0x01, 0x01, 0x1D, 0x00, 0xE2, 0xFF, 0x54, 0x68, 0x69, 0x73, 0x20,
0x69, 0x73, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6D, 0x70, 0x6C, 0x65, 0x20,
0x74, 0x65, 0x78, 0x74, 0x20, 0x66, 0x69, 0x6C, 0x65, 0x20, 0x3A, 0x29,
@ -20,6 +20,6 @@ TEST_CASE(zlib_decompress_simple)
const u8 uncompressed[] = "This is a simple text file :)";
const auto decompressed = Compress::Zlib::decompress_all(compressed);
auto const decompressed = Compress::Zlib::decompress_all(compressed);
EXPECT(decompressed.value().bytes() == (ReadonlyBytes { uncompressed, sizeof(uncompressed) - 1 }));
}

2
Tests/LibCpp/test-cpp-parser.cpp
View file

@ -72,7 +72,7 @@ TEST_CASE(test_regression)
fclose(input_stream);
String content { reinterpret_cast<const char*>(buffer.data()), buffer.size() };
String content { reinterpret_cast<char const*>(buffer.data()), buffer.size() };
auto equal = content == target_ast;
EXPECT(equal);

2
Tests/LibCrypto/TestAES.cpp
View file

@ -10,7 +10,7 @@
#include <LibTest/TestCase.h>
#include <cstring>
static ReadonlyBytes operator""_b(const char* string, size_t length)
static ReadonlyBytes operator""_b(char const* string, size_t length)
{
return ReadonlyBytes(string, length);
}

2
Tests/LibCrypto/TestRSA.cpp
View file

@ -10,7 +10,7 @@
#include <LibTest/TestCase.h>
#include <cstring>
static ByteBuffer operator""_b(const char* string, size_t length)
static ByteBuffer operator""_b(char const* string, size_t length)
{
return ByteBuffer::copy(string, length).release_value();
}

12
Tests/LibGfx/BenchmarkGfxPainter.cpp
View file

@ -22,8 +22,8 @@ static struct FontDatabaseSpoofer {
BENCHMARK_CASE(diagonal_lines)
{
const int run_count = 50;
const int bitmap_size = 2000;
int const run_count = 50;
int const bitmap_size = 2000;
auto bitmap = Gfx::Bitmap::try_create(Gfx::BitmapFormat::BGRx8888, { bitmap_size, bitmap_size }).release_value_but_fixme_should_propagate_errors();
Gfx::Painter painter(bitmap);
@ -38,8 +38,8 @@ BENCHMARK_CASE(diagonal_lines)
BENCHMARK_CASE(fill)
{
const int run_count = 1000;
const int bitmap_size = 2000;
int const run_count = 1000;
int const bitmap_size = 2000;
auto bitmap = Gfx::Bitmap::try_create(Gfx::BitmapFormat::BGRx8888, { bitmap_size, bitmap_size }).release_value_but_fixme_should_propagate_errors();
Gfx::Painter painter(bitmap);
@ -51,8 +51,8 @@ BENCHMARK_CASE(fill)
BENCHMARK_CASE(fill_with_gradient)
{
const int run_count = 50;
const int bitmap_size = 2000;
int const run_count = 50;
int const bitmap_size = 2000;
auto bitmap = Gfx::Bitmap::try_create(Gfx::BitmapFormat::BGRx8888, { bitmap_size, bitmap_size }).release_value_but_fixme_should_propagate_errors();
Gfx::Painter painter(bitmap);

8
Tests/LibGfx/TestFontHandling.cpp
View file

@ -14,7 +14,7 @@
TEST_CASE(test_fontdatabase_get_by_name)
{
const char* name = "Liza 10 400 0";
char const* name = "Liza 10 400 0";
auto& font_database = Gfx::FontDatabase::the();
EXPECT(!font_database.get_by_name(name)->name().is_null());
}
@ -28,7 +28,7 @@ TEST_CASE(test_fontdatabase_get)
TEST_CASE(test_fontdatabase_for_each_font)
{
auto& font_database = Gfx::FontDatabase::the();
font_database.for_each_font([&](const Gfx::Font& font) {
font_database.for_each_font([&](Gfx::Font const& font) {
EXPECT(!font.name().is_null());
EXPECT(!font.qualified_name().is_null());
EXPECT(!font.family().is_null());
@ -55,7 +55,7 @@ TEST_CASE(test_set_name)
u8 glyph_width = 1;
auto font = Gfx::BitmapFont::create(glyph_height, glyph_width, true, 256);
const char* name = "my newly created font";
char const* name = "my newly created font";
font->set_name(name);
EXPECT(!font->name().is_null());
@ -68,7 +68,7 @@ TEST_CASE(test_set_family)
u8 glyph_width = 1;
auto font = Gfx::BitmapFont::create(glyph_height, glyph_width, true, 256);
const char* family = "my newly created font family";
char const* family = "my newly created font family";
font->set_family(family);
EXPECT(!font->family().is_null());

4
Tests/LibIMAP/TestQuotedPrintable.cpp
View file

@ -10,12 +10,12 @@
TEST_CASE(test_decode)
{
auto decode_equal = [](const char* input, const char* expected) {
auto decode_equal = [](char const* input, char const* expected) {
auto decoded = IMAP::decode_quoted_printable(StringView(input));
EXPECT(String::copy(decoded) == String(expected));
};
auto decode_equal_byte_buffer = [](const char* input, const char* expected, size_t expected_length) {
auto decode_equal_byte_buffer = [](char const* input, char const* expected, size_t expected_length) {
auto decoded = IMAP::decode_quoted_printable(StringView(input));
EXPECT(decoded == ByteBuffer::copy(expected, expected_length).value());
};

4
Tests/LibM/test-math.cpp
View file

@ -120,7 +120,7 @@ union Extractor {
};
double d;
bool operator==(const Extractor& other) const
bool operator==(Extractor const& other) const
{
return other.sign == sign && other.exponent == exponent && other.mantissa == mantissa;
}
@ -227,7 +227,7 @@ TEST_CASE(gamma)
EXPECT(isnan(tgamma(-5)));
// TODO: investigate Stirling approximation implementation of gamma function
//EXPECT_APPROXIMATE(tgamma(0.5), sqrt(M_PI));
// EXPECT_APPROXIMATE(tgamma(0.5), sqrt(M_PI));
EXPECT_EQ(tgammal(21.0l), 2'432'902'008'176'640'000.0l);
EXPECT_EQ(tgamma(19.0), 6'402'373'705'728'000.0);
EXPECT_EQ(tgammaf(11.0f), 3628800.0f);

18
Tests/LibRegex/RegexLibC.cpp
View file

@ -407,7 +407,7 @@ TEST_CASE(parens_qualifier_questionmark)
regex_t regex;
static constexpr int num_matches { 5 };
regmatch_t matches[num_matches];
const char* match_str;
char const* match_str;
EXPECT_EQ(regcomp(&regex, pattern.characters(), REG_EXTENDED), REG_NOERR);
@ -437,7 +437,7 @@ TEST_CASE(parens_qualifier_asterisk)
regex_t regex;
static constexpr int num_matches { 6 };
regmatch_t matches[num_matches];
const char* match_str;
char const* match_str;
EXPECT_EQ(regcomp(&regex, pattern.characters(), REG_EXTENDED), REG_NOERR);
@ -483,7 +483,7 @@ TEST_CASE(parens_qualifier_asterisk_2)
regex_t regex;
static constexpr int num_matches { 6 };
regmatch_t matches[num_matches];
const char* match_str;
char const* match_str;
EXPECT_EQ(regcomp(&regex, pattern.characters(), REG_EXTENDED), REG_NOERR);
@ -527,7 +527,7 @@ TEST_CASE(mulit_parens_qualifier_too_less_result_values)
regex_t regex;
static constexpr int num_matches { 4 };
regmatch_t matches[num_matches];
const char* match_str;
char const* match_str;
matches[3] = { -2, -2, 100 };
@ -591,7 +591,7 @@ TEST_CASE(multi_parens_qualifier_questionmark)
regex_t regex;
static constexpr int num_matches { 8 };
regmatch_t matches[num_matches];
const char* match_str;
char const* match_str;
EXPECT_EQ(regcomp(&regex, pattern.characters(), REG_EXTENDED), REG_NOERR);
@ -682,7 +682,7 @@ TEST_CASE(alternative_match_groups)
regex_t regex;
static constexpr int num_matches { 8 };
regmatch_t matches[num_matches];
const char* match_str;
char const* match_str;
EXPECT_EQ(regcomp(&regex, pattern.characters(), REG_EXTENDED), REG_NOERR);
@ -788,7 +788,7 @@ TEST_CASE(parens_qualifier_exact)
regex_t regex;
static constexpr int num_matches { 5 };
regmatch_t matches[num_matches];
const char* match_str;
char const* match_str;
EXPECT_EQ(regcomp(&regex, pattern.characters(), REG_EXTENDED), REG_NOERR);
@ -835,7 +835,7 @@ TEST_CASE(parens_qualifier_minimum)
regex_t regex;
static constexpr int num_matches { 5 };
regmatch_t matches[num_matches];
const char* match_str;
char const* match_str;
EXPECT_EQ(regcomp(&regex, pattern.characters(), REG_EXTENDED), REG_NOERR);
@ -893,7 +893,7 @@ TEST_CASE(parens_qualifier_maximum)
regex_t regex;
static constexpr int num_matches { 5 };
regmatch_t matches[num_matches];
const char* match_str;
char const* match_str;
EXPECT_EQ(regcomp(&regex, pattern.characters(), REG_EXTENDED), REG_NOERR);

2
Tests/LibSQL/TestSqlStatementExecution.cpp
View file

@ -19,7 +19,7 @@
namespace {
constexpr const char* db_name = "/tmp/test.db";
constexpr char const* db_name = "/tmp/test.db";
SQL::ResultOr<SQL::ResultSet> try_execute(NonnullRefPtr<SQL::Database> database, String const& sql)
{

6
Tests/LibTLS/TestTLSHandshake.cpp
View file

@ -11,12 +11,12 @@
#include <LibTLS/TLSv12.h>
#include <LibTest/TestCase.h>
static const char* ca_certs_file = "./ca_certs.ini";
static char const* ca_certs_file = "./ca_certs.ini";
static int port = 443;
constexpr const char* DEFAULT_SERVER { "www.google.com" };
constexpr char const* DEFAULT_SERVER { "www.google.com" };
static ByteBuffer operator""_b(const char* string, size_t length)
static ByteBuffer operator""_b(char const* string, size_t length)
{
return ByteBuffer::copy(string, length).release_value();
}

10
Tests/LibWasm/test-wasm.cpp
View file

@ -170,10 +170,10 @@ JS_DEFINE_NATIVE_FUNCTION(WebAssemblyModule::get_export)
return JS::Value(static_cast<unsigned long>(ptr->value()));
if (auto v = value.get_pointer<Wasm::GlobalAddress>()) {
return m_machine.store().get(*v)->value().value().visit(
[&](const auto& value) -> JS::Value { return JS::Value(static_cast<double>(value)); },
[&](auto const& value) -> JS::Value { return JS::Value(static_cast<double>(value)); },
[&](i32 value) { return JS::Value(static_cast<double>(value)); },
[&](i64 value) -> JS::Value { return JS::js_bigint(vm, Crypto::SignedBigInteger::create_from(value)); },
[&](const Wasm::Reference& reference) -> JS::Value {
[&](Wasm::Reference const& reference) -> JS::Value {
return reference.ref().visit(
[&](const Wasm::Reference::Null&) -> JS::Value { return JS::js_null(); },
[&](const auto& ref) -> JS::Value { return JS::Value(static_cast<double>(ref.address.value())); });
@ -193,7 +193,7 @@ JS_DEFINE_NATIVE_FUNCTION(WebAssemblyModule::wasm_invoke)
if (!function_instance)
return vm.throw_completion<JS::TypeError>(global_object, "Invalid function address");
const Wasm::FunctionType* type { nullptr };
Wasm::FunctionType const* type { nullptr };
function_instance->visit([&](auto& value) { type = &value.type(); });
if (!type)
return vm.throw_completion<JS::TypeError>(global_object, "Invalid function found at given address");
@ -249,10 +249,10 @@ JS_DEFINE_NATIVE_FUNCTION(WebAssemblyModule::wasm_invoke)
JS::Value return_value;
result.values().first().value().visit(
[&](const auto& value) { return_value = JS::Value(static_cast<double>(value)); },
[&](auto const& value) { return_value = JS::Value(static_cast<double>(value)); },
[&](i32 value) { return_value = JS::Value(static_cast<double>(value)); },
[&](i64 value) { return_value = JS::Value(JS::js_bigint(vm, Crypto::SignedBigInteger::create_from(value))); },
[&](const Wasm::Reference& reference) {
[&](Wasm::Reference const& reference) {
reference.ref().visit(
[&](const Wasm::Reference::Null&) { return_value = JS::js_null(); },
[&](const auto& ref) { return_value = JS::Value(static_cast<double>(ref.address.value())); });

8
Tests/UserspaceEmulator/ue-write-oob.cpp
View file

@ -11,10 +11,10 @@
#include <stdlib.h>
#include <sys/mman.h>
static void write8(void* ptr) { *(volatile uint8_t*)ptr = 1; }
static void write16(void* ptr) { *(volatile uint16_t*)ptr = 1; }
static void write32(void* ptr) { *(volatile uint32_t*)ptr = 1; }
static void write64(void* ptr) { *(volatile double*)ptr = 1.0; }
static void write8(void* ptr) { *(uint8_t volatile*)ptr = 1; }
static void write16(void* ptr) { *(uint16_t volatile*)ptr = 1; }
static void write32(void* ptr) { *(uint32_t volatile*)ptr = 1; }
static void write64(void* ptr) { *(double volatile*)ptr = 1.0; }
// A u64 write might be translated by the compiler as a 32-then-32-bit write:
// static void write64_bad(void* ptr) { *(volatile uint64_t*)ptr = 1.0; }
// Let's hope this won't be translated like that.