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

Tests: Prefer TRY_OR_FAIL() and MUST() over EXPECT(!.is_error())

Browse source 
Note that in some cases (in particular SQL::Result and PDFErrorOr),
there is no Formatter defined for the error type, hence TRY_OR_FAIL
cannot work as-is. Furthermore, this commit leaves untouched the places
where MUST could be replaced by TRY_OR_FAIL.

Inspired by:
https://github.com/SerenityOS/serenity/pull/18710#discussion_r1186892445
This commit is contained in:
Ben Wiederhake 2023-05-07 20:14:06 +02:00 • committed by Andrew Kaster
parent 87a7299078
commit f890b70eae
23 changed files with 415 additions and 742 deletions
Download patch file Download diff file Expand all files Collapse all files

167
Tests/LibCore/TestLibCoreFilePermissionsMask.cpp
View file

@ -9,106 +9,96 @@
TEST_CASE(file_permission_mask_from_symbolic_notation)
{
auto mask = Core::FilePermissionsMask::from_symbolic_notation(""sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().clear_mask(), 0);
EXPECT_EQ(mask.value().write_mask(), 0);
EXPECT_EQ(mask.value().apply(0), 0);
EXPECT_EQ(mask.value().apply(0664), 0664);
auto mask = TRY_OR_FAIL(Core::FilePermissionsMask::from_symbolic_notation(""sv));
EXPECT_EQ(mask.clear_mask(), 0);
EXPECT_EQ(mask.write_mask(), 0);
EXPECT_EQ(mask.apply(0), 0);
EXPECT_EQ(mask.apply(0664), 0664);
mask = Core::FilePermissionsMask::from_symbolic_notation("u+rwx"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().clear_mask(), 0);
EXPECT_EQ(mask.value().write_mask(), 0700);
EXPECT_EQ(mask.value().apply(0), 0700);
EXPECT_EQ(mask.value().apply(0664), 0764);
mask = TRY_OR_FAIL(Core::FilePermissionsMask::from_symbolic_notation("u+rwx"sv));
EXPECT_EQ(mask.clear_mask(), 0);
EXPECT_EQ(mask.write_mask(), 0700);
EXPECT_EQ(mask.apply(0), 0700);
EXPECT_EQ(mask.apply(0664), 0764);
mask = Core::FilePermissionsMask::from_symbolic_notation("g+rwx"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().clear_mask(), 0);
EXPECT_EQ(mask.value().write_mask(), 0070);
EXPECT_EQ(mask.value().apply(0), 0070);
EXPECT_EQ(mask.value().apply(0664), 0674);
mask = TRY_OR_FAIL(Core::FilePermissionsMask::from_symbolic_notation("g+rwx"sv));
EXPECT_EQ(mask.clear_mask(), 0);
EXPECT_EQ(mask.write_mask(), 0070);
EXPECT_EQ(mask.apply(0), 0070);
EXPECT_EQ(mask.apply(0664), 0674);
mask = Core::FilePermissionsMask::from_symbolic_notation("o+rwx"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().clear_mask(), 0);
EXPECT_EQ(mask.value().write_mask(), 0007);
EXPECT_EQ(mask.value().apply(0), 0007);
EXPECT_EQ(mask.value().apply(0664), 0667);
mask = TRY_OR_FAIL(Core::FilePermissionsMask::from_symbolic_notation("o+rwx"sv));
EXPECT_EQ(mask.clear_mask(), 0);
EXPECT_EQ(mask.write_mask(), 0007);
EXPECT_EQ(mask.apply(0), 0007);
EXPECT_EQ(mask.apply(0664), 0667);
mask = Core::FilePermissionsMask::from_symbolic_notation("a=rx"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().clear_mask(), 0777);
EXPECT_EQ(mask.value().write_mask(), 0555);
EXPECT_EQ(mask.value().apply(0), 0555);
EXPECT_EQ(mask.value().apply(0664), 0555);
mask = TRY_OR_FAIL(Core::FilePermissionsMask::from_symbolic_notation("a=rx"sv));
EXPECT_EQ(mask.clear_mask(), 0777);
EXPECT_EQ(mask.write_mask(), 0555);
EXPECT_EQ(mask.apply(0), 0555);
EXPECT_EQ(mask.apply(0664), 0555);
mask = Core::FilePermissionsMask::from_symbolic_notation("ugo=rx"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().clear_mask(), 0777);
EXPECT_EQ(mask.value().write_mask(), 0555);
EXPECT_EQ(mask.value().apply(0), 0555);
EXPECT_EQ(mask.value().apply(0664), 0555);
mask = TRY_OR_FAIL(Core::FilePermissionsMask::from_symbolic_notation("ugo=rx"sv));
EXPECT_EQ(mask.clear_mask(), 0777);
EXPECT_EQ(mask.write_mask(), 0555);
EXPECT_EQ(mask.apply(0), 0555);
EXPECT_EQ(mask.apply(0664), 0555);
mask = Core::FilePermissionsMask::from_symbolic_notation("u+rw,g=rx,o-rwx"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().clear_mask(), 0077);
EXPECT_EQ(mask.value().write_mask(), 0650);
EXPECT_EQ(mask.value().apply(0), 0650);
EXPECT_EQ(mask.value().apply(0177), 0750);
mask = TRY_OR_FAIL(Core::FilePermissionsMask::from_symbolic_notation("u+rw,g=rx,o-rwx"sv));
EXPECT_EQ(mask.clear_mask(), 0077);
EXPECT_EQ(mask.write_mask(), 0650);
EXPECT_EQ(mask.apply(0), 0650);
EXPECT_EQ(mask.apply(0177), 0750);
mask = Core::FilePermissionsMask::from_symbolic_notation("+r"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().clear_mask(), 0);
EXPECT_EQ(mask.value().write_mask(), 0444);
EXPECT_EQ(mask.value().apply(0), 0444);
EXPECT_EQ(mask.value().apply(0123), 0567);
mask = TRY_OR_FAIL(Core::FilePermissionsMask::from_symbolic_notation("+r"sv));
EXPECT_EQ(mask.clear_mask(), 0);
EXPECT_EQ(mask.write_mask(), 0444);
EXPECT_EQ(mask.apply(0), 0444);
EXPECT_EQ(mask.apply(0123), 0567);
mask = Core::FilePermissionsMask::from_symbolic_notation("=rx"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().clear_mask(), 0777);
EXPECT_EQ(mask.value().write_mask(), 0555);
EXPECT_EQ(mask.value().apply(0), 0555);
EXPECT_EQ(mask.value().apply(0664), 0555);
mask = TRY_OR_FAIL(Core::FilePermissionsMask::from_symbolic_notation("=rx"sv));
EXPECT_EQ(mask.clear_mask(), 0777);
EXPECT_EQ(mask.write_mask(), 0555);
EXPECT_EQ(mask.apply(0), 0555);
EXPECT_EQ(mask.apply(0664), 0555);
mask = Core::FilePermissionsMask::from_symbolic_notation("a+X"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().clear_mask(), 0);
EXPECT_EQ(mask.value().write_mask(), 0);
EXPECT_EQ(mask.value().directory_or_executable_mask().clear_mask(), 0);
EXPECT_EQ(mask.value().directory_or_executable_mask().write_mask(), 0111);
EXPECT_EQ(mask.value().apply(0), 0);
EXPECT_EQ(mask.value().apply(0100), 0111);
EXPECT_EQ(mask.value().apply(S_IFDIR | 0), S_IFDIR | 0111);
mask = TRY_OR_FAIL(Core::FilePermissionsMask::from_symbolic_notation("a+X"sv));
EXPECT_EQ(mask.clear_mask(), 0);
EXPECT_EQ(mask.write_mask(), 0);
EXPECT_EQ(mask.directory_or_executable_mask().clear_mask(), 0);
EXPECT_EQ(mask.directory_or_executable_mask().write_mask(), 0111);
EXPECT_EQ(mask.apply(0), 0);
EXPECT_EQ(mask.apply(0100), 0111);
EXPECT_EQ(mask.apply(S_IFDIR | 0), S_IFDIR | 0111);
mask = Core::FilePermissionsMask::from_symbolic_notation("z+rw"sv);
EXPECT(mask.is_error());
EXPECT(mask.error().string_literal().starts_with("invalid class"sv));
auto mask_error = Core::FilePermissionsMask::from_symbolic_notation("z+rw"sv);
EXPECT(mask_error.is_error());
EXPECT(mask_error.error().string_literal().starts_with("invalid class"sv));
mask = Core::FilePermissionsMask::from_symbolic_notation("u*rw"sv);
EXPECT(mask.is_error());
EXPECT(mask.error().string_literal().starts_with("invalid operation"sv));
mask_error = Core::FilePermissionsMask::from_symbolic_notation("u*rw"sv);
EXPECT(mask_error.is_error());
EXPECT(mask_error.error().string_literal().starts_with("invalid operation"sv));
mask = Core::FilePermissionsMask::from_symbolic_notation("u+rz"sv);
EXPECT(mask.is_error());
EXPECT(mask.error().string_literal().starts_with("invalid symbolic permission"sv));
mask_error = Core::FilePermissionsMask::from_symbolic_notation("u+rz"sv);
EXPECT(mask_error.is_error());
EXPECT(mask_error.error().string_literal().starts_with("invalid symbolic permission"sv));
mask = Core::FilePermissionsMask::from_symbolic_notation("u+rw;g+rw"sv);
EXPECT(mask.is_error());
EXPECT(mask.error().string_literal().starts_with("invalid symbolic permission"sv));
mask_error = Core::FilePermissionsMask::from_symbolic_notation("u+rw;g+rw"sv);
EXPECT(mask_error.is_error());
EXPECT(mask_error.error().string_literal().starts_with("invalid symbolic permission"sv));
}
TEST_CASE(file_permission_mask_parse)
{
auto numeric_mask = Core::FilePermissionsMask::parse("750"sv);
auto symbolic_mask = Core::FilePermissionsMask::parse("u=rwx,g=rx,o-rwx"sv);
auto numeric_mask = TRY_OR_FAIL(Core::FilePermissionsMask::parse("750"sv));
auto symbolic_mask = TRY_OR_FAIL(Core::FilePermissionsMask::parse("u=rwx,g=rx,o-rwx"sv));
EXPECT_EQ(numeric_mask.value().apply(0), 0750);
EXPECT_EQ(symbolic_mask.value().apply(0), 0750);
EXPECT_EQ(numeric_mask.apply(0), 0750);
EXPECT_EQ(symbolic_mask.apply(0), 0750);
EXPECT_EQ(numeric_mask.value().clear_mask(), symbolic_mask.value().clear_mask());
EXPECT_EQ(numeric_mask.value().write_mask(), symbolic_mask.value().write_mask());
EXPECT_EQ(numeric_mask.clear_mask(), symbolic_mask.clear_mask());
EXPECT_EQ(numeric_mask.write_mask(), symbolic_mask.write_mask());
auto mask = Core::FilePermissionsMask::parse("888"sv);
EXPECT(mask.is_error());
@ -120,20 +110,17 @@ TEST_CASE(file_permission_mask_parse)
TEST_CASE(numeric_mask_special_bits)
{
{
auto mask = Core::FilePermissionsMask::parse("750"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().apply(07000), 07750);
auto mask = TRY_OR_FAIL(Core::FilePermissionsMask::parse("750"sv));
EXPECT_EQ(mask.apply(07000), 07750);
}
{
auto mask = Core::FilePermissionsMask::parse("7750"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().apply(0), 07750);
auto mask = TRY_OR_FAIL(Core::FilePermissionsMask::parse("7750"sv));
EXPECT_EQ(mask.apply(0), 07750);
}
{
auto mask = Core::FilePermissionsMask::parse("0750"sv);
EXPECT(!mask.is_error());
EXPECT_EQ(mask.value().apply(07000), 0750);
auto mask = TRY_OR_FAIL(Core::FilePermissionsMask::parse("0750"sv));
EXPECT_EQ(mask.apply(07000), 0750);
}
}

8
Tests/LibCore/TestLibCoreSharedSingleProducerCircularQueue.cpp
View file

@ -20,7 +20,7 @@ TEST_CASE(simple_enqueue)
{
auto queue = MUST(TestQueue::create());
for (size_t i = 0; i < queue.size() - 1; ++i)
EXPECT(!queue.enqueue((int)i).is_error());
MUST(queue.enqueue((int)i));
auto result = queue.enqueue(0);
EXPECT(result.is_error());
@ -34,9 +34,9 @@ TEST_CASE(simple_dequeue)
for (int i = 0; i < test_count; ++i)
(void)queue.enqueue(i);
for (int i = 0; i < test_count; ++i) {
auto const element = queue.dequeue();
EXPECT(!element.is_error());
EXPECT_EQ(element.value(), i);
// TODO: This could be TRY_OR_FAIL(), if someone implements Formatter<SharedSingleProducerCircularQueue::QueueStatus>.
auto const element = MUST(queue.dequeue());
EXPECT_EQ(element, i);
}
}

257
Tests/LibCore/TestLibCoreStream.cpp
View file

@ -34,37 +34,29 @@ TEST_CASE(file_open)
EXPECT(file->is_open());
EXPECT(!file->is_eof());
auto maybe_size = file->size();
EXPECT(!maybe_size.is_error());
EXPECT_EQ(maybe_size.value(), 0ul);
auto size = TRY_OR_FAIL(file->size());
EXPECT_EQ(size, 0ul);
}
TEST_CASE(file_write_bytes)
{
auto maybe_file = Core::File::open("/tmp/file-write-bytes-test.txt"sv, Core::File::OpenMode::Write);
auto file = maybe_file.release_value();
auto file = TRY_OR_FAIL(Core::File::open("/tmp/file-write-bytes-test.txt"sv, Core::File::OpenMode::Write));
constexpr auto some_words = "These are some words"sv;
ReadonlyBytes buffer { some_words.characters_without_null_termination(), some_words.length() };
auto result = file->write_some(buffer);
EXPECT(!result.is_error());
TRY_OR_FAIL(file->write_some(buffer));
}
constexpr auto expected_buffer_contents = "&lt;small&gt;(Please consider translating this message for the benefit of your fellow Wikimedians. Please also consider translating"sv;
TEST_CASE(file_read_bytes)
{
auto maybe_file = Core::File::open("/usr/Tests/LibCore/long_lines.txt"sv, Core::File::OpenMode::Read);
EXPECT(!maybe_file.is_error());
auto file = maybe_file.release_value();
auto file = TRY_OR_FAIL(Core::File::open("/usr/Tests/LibCore/long_lines.txt"sv, Core::File::OpenMode::Read));
auto maybe_buffer = ByteBuffer::create_uninitialized(131);
EXPECT(!maybe_buffer.is_error());
auto buffer = maybe_buffer.release_value();
auto buffer = TRY_OR_FAIL(ByteBuffer::create_uninitialized(131));
auto result = file->read_some(buffer);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().size(), 131ul);
EXPECT_EQ(TRY_OR_FAIL(result).size(), 131ul);
StringView buffer_contents { buffer.bytes() };
EXPECT_EQ(buffer_contents, expected_buffer_contents);
@ -76,31 +68,27 @@ constexpr auto expected_seek_contents3 = "levels of advanc"sv;
TEST_CASE(file_seeking_around)
{
auto maybe_file = Core::File::open("/usr/Tests/LibCore/long_lines.txt"sv, Core::File::OpenMode::Read);
EXPECT(!maybe_file.is_error());
auto file = maybe_file.release_value();
auto file = TRY_OR_FAIL(Core::File::open("/usr/Tests/LibCore/long_lines.txt"sv, Core::File::OpenMode::Read));
EXPECT_EQ(file->size().release_value(), 8702ul);
auto maybe_buffer = ByteBuffer::create_uninitialized(16);
EXPECT(!maybe_buffer.is_error());
auto buffer = maybe_buffer.release_value();
auto buffer = TRY_OR_FAIL(ByteBuffer::create_uninitialized(16));
StringView buffer_contents { buffer.bytes() };
EXPECT(!file->seek(500, SeekMode::SetPosition).is_error());
TRY_OR_FAIL(file->seek(500, SeekMode::SetPosition));
EXPECT_EQ(file->tell().release_value(), 500ul);
EXPECT(!file->read_until_filled(buffer).is_error());
TRY_OR_FAIL(file->read_until_filled(buffer));
EXPECT_EQ(buffer_contents, expected_seek_contents1);
EXPECT(!file->seek(234, SeekMode::FromCurrentPosition).is_error());
TRY_OR_FAIL(file->seek(234, SeekMode::FromCurrentPosition));
EXPECT_EQ(file->tell().release_value(), 750ul);
EXPECT(!file->read_until_filled(buffer).is_error());
TRY_OR_FAIL(file->read_until_filled(buffer));
EXPECT_EQ(buffer_contents, expected_seek_contents2);
EXPECT(!file->seek(-105, SeekMode::FromEndPosition).is_error());
TRY_OR_FAIL(file->seek(-105, SeekMode::FromEndPosition));
EXPECT_EQ(file->tell().release_value(), 8597ul);
EXPECT(!file->read_until_filled(buffer).is_error());
TRY_OR_FAIL(file->read_until_filled(buffer));
EXPECT_EQ(buffer_contents, expected_seek_contents3);
}
@ -109,21 +97,17 @@ TEST_CASE(file_adopt_fd)
int rc = ::open("/usr/Tests/LibCore/long_lines.txt", O_RDONLY);
EXPECT(rc >= 0);
auto maybe_file = Core::File::adopt_fd(rc, Core::File::OpenMode::Read);
EXPECT(!maybe_file.is_error());
auto file = maybe_file.release_value();
auto file = TRY_OR_FAIL(Core::File::adopt_fd(rc, Core::File::OpenMode::Read));
EXPECT_EQ(file->size().release_value(), 8702ul);
auto maybe_buffer = ByteBuffer::create_uninitialized(16);
EXPECT(!maybe_buffer.is_error());
auto buffer = maybe_buffer.release_value();
auto buffer = TRY_OR_FAIL(ByteBuffer::create_uninitialized(16));
StringView buffer_contents { buffer.bytes() };
EXPECT(!file->seek(500, SeekMode::SetPosition).is_error());
TRY_OR_FAIL(file->seek(500, SeekMode::SetPosition));
EXPECT_EQ(file->tell().release_value(), 500ul);
EXPECT(!file->read_until_filled(buffer).is_error());
TRY_OR_FAIL(file->read_until_filled(buffer));
EXPECT_EQ(buffer_contents, expected_seek_contents1);
// A single seek & read test should be fine for now.
@ -138,13 +122,12 @@ TEST_CASE(file_adopt_invalid_fd)
TEST_CASE(file_truncate)
{
auto maybe_file = Core::File::open("/tmp/file-truncate-test.txt"sv, Core::File::OpenMode::Write);
auto file = maybe_file.release_value();
auto file = TRY_OR_FAIL(Core::File::open("/tmp/file-truncate-test.txt"sv, Core::File::OpenMode::Write));
EXPECT(!file->truncate(999).is_error());
TRY_OR_FAIL(file->truncate(999));
EXPECT_EQ(file->size().release_value(), 999ul);
EXPECT(!file->truncate(42).is_error());
TRY_OR_FAIL(file->truncate(42));
EXPECT_EQ(file->size().release_value(), 42ul);
}
@ -170,33 +153,23 @@ TEST_CASE(tcp_socket_read)
// Core::EventLoop through Core::Notifier.
Core::EventLoop event_loop;
auto maybe_tcp_server = Core::TCPServer::try_create();
EXPECT(!maybe_tcp_server.is_error());
auto tcp_server = maybe_tcp_server.release_value();
EXPECT(!tcp_server->listen({ 127, 0, 0, 1 }, 9090).is_error());
EXPECT(!tcp_server->set_blocking(true).is_error());
auto tcp_server = TRY_OR_FAIL(Core::TCPServer::try_create());
TRY_OR_FAIL(tcp_server->listen({ 127, 0, 0, 1 }, 9090));
TRY_OR_FAIL(tcp_server->set_blocking(true));
auto maybe_client_socket = Core::TCPSocket::connect({ { 127, 0, 0, 1 }, 9090 });
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
auto client_socket = TRY_OR_FAIL(Core::TCPSocket::connect({ { 127, 0, 0, 1 }, 9090 }));
EXPECT(client_socket->is_open());
auto maybe_server_socket = tcp_server->accept();
EXPECT(!maybe_server_socket.is_error());
auto server_socket = maybe_server_socket.release_value();
EXPECT(!server_socket->write_some({ sent_data.characters_without_null_termination(), sent_data.length() }).is_error());
auto server_socket = TRY_OR_FAIL(tcp_server->accept());
TRY_OR_FAIL(server_socket->write_some({ sent_data.characters_without_null_termination(), sent_data.length() }));
server_socket->close();
EXPECT(client_socket->can_read_without_blocking(100).release_value());
EXPECT_EQ(client_socket->pending_bytes().release_value(), sent_data.length());
auto maybe_receive_buffer = ByteBuffer::create_uninitialized(64);
EXPECT(!maybe_receive_buffer.is_error());
auto receive_buffer = maybe_receive_buffer.release_value();
auto maybe_read_bytes = client_socket->read_some(receive_buffer);
EXPECT(!maybe_read_bytes.is_error());
auto read_bytes = maybe_read_bytes.release_value();
auto receive_buffer = TRY_OR_FAIL(ByteBuffer::create_uninitialized(64));
auto read_bytes = TRY_OR_FAIL(client_socket->read_some(receive_buffer));
StringView received_data { read_bytes };
EXPECT_EQ(sent_data, received_data);
@ -206,30 +179,20 @@ TEST_CASE(tcp_socket_write)
{
Core::EventLoop event_loop;
auto maybe_tcp_server = Core::TCPServer::try_create();
EXPECT(!maybe_tcp_server.is_error());
auto tcp_server = maybe_tcp_server.release_value();
EXPECT(!tcp_server->listen({ 127, 0, 0, 1 }, 9090).is_error());
EXPECT(!tcp_server->set_blocking(true).is_error());
auto tcp_server = TRY_OR_FAIL(Core::TCPServer::try_create());
TRY_OR_FAIL(tcp_server->listen({ 127, 0, 0, 1 }, 9090));
TRY_OR_FAIL(tcp_server->set_blocking(true));
auto maybe_client_socket = Core::TCPSocket::connect({ { 127, 0, 0, 1 }, 9090 });
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
auto client_socket = TRY_OR_FAIL(Core::TCPSocket::connect({ { 127, 0, 0, 1 }, 9090 }));
auto maybe_server_socket = tcp_server->accept();
EXPECT(!maybe_server_socket.is_error());
auto server_socket = maybe_server_socket.release_value();
EXPECT(!server_socket->set_blocking(true).is_error());
auto server_socket = TRY_OR_FAIL(tcp_server->accept());
TRY_OR_FAIL(server_socket->set_blocking(true));
EXPECT(!client_socket->write_until_depleted({ sent_data.characters_without_null_termination(), sent_data.length() }).is_error());
TRY_OR_FAIL(client_socket->write_until_depleted({ sent_data.characters_without_null_termination(), sent_data.length() }));
client_socket->close();
auto maybe_receive_buffer = ByteBuffer::create_uninitialized(64);
EXPECT(!maybe_receive_buffer.is_error());
auto receive_buffer = maybe_receive_buffer.release_value();
auto maybe_read_bytes = server_socket->read_some(receive_buffer);
EXPECT(!maybe_read_bytes.is_error());
auto read_bytes = maybe_read_bytes.release_value();
auto receive_buffer = TRY_OR_FAIL(ByteBuffer::create_uninitialized(64));
auto read_bytes = TRY_OR_FAIL(server_socket->read_some(receive_buffer));
StringView received_data { read_bytes };
EXPECT_EQ(sent_data, received_data);
@ -239,15 +202,11 @@ TEST_CASE(tcp_socket_eof)
{
Core::EventLoop event_loop;
auto maybe_tcp_server = Core::TCPServer::try_create();
EXPECT(!maybe_tcp_server.is_error());
auto tcp_server = maybe_tcp_server.release_value();
EXPECT(!tcp_server->listen({ 127, 0, 0, 1 }, 9090).is_error());
EXPECT(!tcp_server->set_blocking(true).is_error());
auto tcp_server = TRY_OR_FAIL(Core::TCPServer::try_create());
TRY_OR_FAIL(tcp_server->listen({ 127, 0, 0, 1 }, 9090));
TRY_OR_FAIL(tcp_server->set_blocking(true));
auto maybe_client_socket = Core::TCPSocket::connect({ { 127, 0, 0, 1 }, 9090 });
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
auto client_socket = TRY_OR_FAIL(Core::TCPSocket::connect({ { 127, 0, 0, 1 }, 9090 }));
EXPECT(client_socket->is_open());
@ -260,9 +219,7 @@ TEST_CASE(tcp_socket_eof)
EXPECT(client_socket->can_read_without_blocking(100).release_value());
EXPECT_EQ(client_socket->pending_bytes().release_value(), 0ul);
auto maybe_receive_buffer = ByteBuffer::create_uninitialized(1);
EXPECT(!maybe_receive_buffer.is_error());
auto receive_buffer = maybe_receive_buffer.release_value();
auto receive_buffer = TRY_OR_FAIL(ByteBuffer::create_uninitialized(1));
EXPECT(client_socket->read_some(receive_buffer).release_value().is_empty());
EXPECT(client_socket->is_eof());
}
@ -280,27 +237,23 @@ TEST_CASE(udp_socket_read_write)
auto udp_server = Core::UDPServer::construct();
EXPECT(udp_server->bind({ 127, 0, 0, 1 }, 9090));
auto maybe_client_socket = Core::UDPSocket::connect({ { 127, 0, 0, 1 }, 9090 });
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
auto client_socket = TRY_OR_FAIL(Core::UDPSocket::connect({ { 127, 0, 0, 1 }, 9090 }));
EXPECT(client_socket->is_open());
EXPECT(!client_socket->write_until_depleted({ sent_data.characters_without_null_termination(), sent_data.length() }).is_error());
TRY_OR_FAIL(client_socket->write_until_depleted({ sent_data.characters_without_null_termination(), sent_data.length() }));
// FIXME: UDPServer::receive sadly doesn't give us a way to block on it,
// currently.
usleep(100000);
struct sockaddr_in client_address;
auto server_receive_buffer_or_error = udp_server->receive(64, client_address);
EXPECT(!server_receive_buffer_or_error.is_error());
auto server_receive_buffer = server_receive_buffer_or_error.release_value();
auto server_receive_buffer = TRY_OR_FAIL(udp_server->receive(64, client_address));
EXPECT(!server_receive_buffer.is_empty());
StringView server_received_data { server_receive_buffer.bytes() };
EXPECT_EQ(server_received_data, sent_data);
EXPECT(!udp_server->send({ udp_reply_data.characters_without_null_termination(), udp_reply_data.length() }, client_address).is_error());
TRY_OR_FAIL(udp_server->send({ udp_reply_data.characters_without_null_termination(), udp_reply_data.length() }, client_address));
EXPECT(client_socket->can_read_without_blocking(100).release_value());
EXPECT_EQ(client_socket->pending_bytes().release_value(), udp_reply_data.length());
@ -309,12 +262,8 @@ TEST_CASE(udp_socket_read_write)
auto small_buffer = ByteBuffer::create_uninitialized(8).release_value();
EXPECT_EQ(client_socket->read_some(small_buffer).error().code(), EMSGSIZE);
auto maybe_client_receive_buffer = ByteBuffer::create_uninitialized(64);
EXPECT(!maybe_client_receive_buffer.is_error());
auto client_receive_buffer = maybe_client_receive_buffer.release_value();
auto maybe_read_bytes = client_socket->read_some(client_receive_buffer);
EXPECT(!maybe_read_bytes.is_error());
auto read_bytes = maybe_read_bytes.release_value();
auto client_receive_buffer = TRY_OR_FAIL(ByteBuffer::create_uninitialized(64));
auto read_bytes = TRY_OR_FAIL(client_socket->read_some(client_receive_buffer));
StringView client_received_data { read_bytes };
EXPECT_EQ(udp_reply_data, client_received_data);
@ -330,7 +279,7 @@ TEST_CASE(local_socket_read)
EXPECT(local_server->listen("/tmp/test-socket"));
local_server->on_accept = [&](NonnullOwnPtr<Core::LocalSocket> server_socket) {
EXPECT(!server_socket->write_some(sent_data.bytes()).is_error());
TRY_OR_FAIL(server_socket->write_some(sent_data.bytes()));
event_loop.quit(0);
event_loop.pump();
@ -344,21 +293,15 @@ TEST_CASE(local_socket_read)
[](auto&) {
Core::EventLoop event_loop;
auto maybe_client_socket = Core::LocalSocket::connect("/tmp/test-socket");
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
auto client_socket = MUST(Core::LocalSocket::connect("/tmp/test-socket"));
EXPECT(client_socket->is_open());
EXPECT(client_socket->can_read_without_blocking(100).release_value());
EXPECT_EQ(client_socket->pending_bytes().release_value(), sent_data.length());
auto maybe_receive_buffer = ByteBuffer::create_uninitialized(64);
EXPECT(!maybe_receive_buffer.is_error());
auto receive_buffer = maybe_receive_buffer.release_value();
auto maybe_read_bytes = client_socket->read_some(receive_buffer);
EXPECT(!maybe_read_bytes.is_error());
auto read_bytes = maybe_read_bytes.release_value();
auto receive_buffer = MUST(ByteBuffer::create_uninitialized(64));
auto read_bytes = MUST(client_socket->read_some(receive_buffer));
StringView received_data { read_bytes };
EXPECT_EQ(sent_data, received_data);
@ -384,14 +327,11 @@ TEST_CASE(local_socket_write)
EXPECT(MUST(server_socket->can_read_without_blocking(100)));
auto pending_bytes = MUST(server_socket->pending_bytes());
auto maybe_receive_buffer = ByteBuffer::create_uninitialized(pending_bytes);
EXPECT(!maybe_receive_buffer.is_error());
auto receive_buffer = maybe_receive_buffer.release_value();
auto maybe_read_bytes = server_socket->read_some(receive_buffer);
EXPECT(!maybe_read_bytes.is_error());
EXPECT_EQ(maybe_read_bytes.value().size(), sent_data.length());
auto receive_buffer = TRY_OR_FAIL(ByteBuffer::create_uninitialized(pending_bytes));
auto read_bytes = TRY_OR_FAIL(server_socket->read_some(receive_buffer));
EXPECT_EQ(read_bytes.size(), sent_data.length());
StringView received_data { maybe_read_bytes.value() };
StringView received_data { read_bytes };
EXPECT_EQ(sent_data, received_data);
event_loop.quit(0);
@ -401,11 +341,9 @@ TEST_CASE(local_socket_write)
// NOTE: Same reason as in the local_socket_read test.
auto background_action = Threading::BackgroundAction<int>::construct(
[](auto&) {
auto maybe_client_socket = Core::LocalSocket::connect("/tmp/test-socket");
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
auto client_socket = MUST(Core::LocalSocket::connect("/tmp/test-socket"));
EXPECT(!client_socket->write_until_depleted({ sent_data.characters_without_null_termination(), sent_data.length() }).is_error());
MUST(client_socket->write_until_depleted({ sent_data.characters_without_null_termination(), sent_data.length() }));
client_socket->close();
return 0;
@ -420,33 +358,25 @@ TEST_CASE(local_socket_write)
TEST_CASE(buffered_long_file_read)
{
auto maybe_file = Core::File::open("/usr/Tests/LibCore/long_lines.txt"sv, Core::File::OpenMode::Read);
EXPECT(!maybe_file.is_error());
auto maybe_buffered_file = Core::InputBufferedFile::create(maybe_file.release_value());
EXPECT(!maybe_buffered_file.is_error());
auto file = maybe_buffered_file.release_value();
auto raw_file = TRY_OR_FAIL(Core::File::open("/usr/Tests/LibCore/long_lines.txt"sv, Core::File::OpenMode::Read));
auto file = TRY_OR_FAIL(Core::InputBufferedFile::create(move(raw_file)));
auto buffer = ByteBuffer::create_uninitialized(4096).release_value();
EXPECT(!file->seek(255, SeekMode::SetPosition).is_error());
TRY_OR_FAIL(file->seek(255, SeekMode::SetPosition));
EXPECT(file->can_read_line().release_value());
auto maybe_line = file->read_line(buffer);
EXPECT(!maybe_line.is_error());
EXPECT_EQ(maybe_line.value().length(), 4095ul); // 4095 bytes on the third line
auto line = TRY_OR_FAIL(file->read_line(buffer));
EXPECT_EQ(line.length(), 4095ul); // 4095 bytes on the third line
// Testing that buffering with seeking works properly
EXPECT(!file->seek(365, SeekMode::SetPosition).is_error());
auto maybe_after_seek_line = file->read_line(buffer);
EXPECT(!maybe_after_seek_line.is_error());
EXPECT_EQ(maybe_after_seek_line.value().length(), 3985ul); // 4095 - 110
TRY_OR_FAIL(file->seek(365, SeekMode::SetPosition));
auto after_seek_line = TRY_OR_FAIL(file->read_line(buffer));
EXPECT_EQ(after_seek_line.length(), 3985ul); // 4095 - 110
}
TEST_CASE(buffered_small_file_read)
{
auto maybe_file = Core::File::open("/usr/Tests/LibCore/small.txt"sv, Core::File::OpenMode::Read);
EXPECT(!maybe_file.is_error());
auto maybe_buffered_file = Core::InputBufferedFile::create(maybe_file.release_value());
EXPECT(!maybe_buffered_file.is_error());
auto file = maybe_buffered_file.release_value();
auto raw_file = TRY_OR_FAIL(Core::File::open("/usr/Tests/LibCore/small.txt"sv, Core::File::OpenMode::Read));
auto file = TRY_OR_FAIL(Core::InputBufferedFile::create(move(raw_file)));
static constexpr StringView expected_lines[] {
"Well"sv,
@ -459,13 +389,12 @@ TEST_CASE(buffered_small_file_read)
auto buffer = ByteBuffer::create_uninitialized(4096).release_value();
for (auto const& line : expected_lines) {
VERIFY(file->can_read_line().release_value());
auto maybe_read_line = file->read_line(buffer);
EXPECT(!maybe_read_line.is_error());
EXPECT_EQ(maybe_read_line.value().length(), line.length());
EXPECT_EQ(StringView(buffer.span().trim(maybe_read_line.value().length())), line);
auto read_line = TRY_OR_FAIL(file->read_line(buffer));
EXPECT_EQ(read_line.length(), line.length());
EXPECT_EQ(StringView(buffer.span().trim(read_line.length())), line);
}
EXPECT(!file->can_read_line().is_error());
EXPECT(!file->can_read_line().value());
bool can_read_line = TRY_OR_FAIL(file->can_read_line());
EXPECT(!can_read_line);
}
TEST_CASE(buffered_file_tell_and_seek)
@ -559,14 +488,13 @@ TEST_CASE(buffered_file_without_newlines)
{
constexpr auto filename = "/tmp/file-without-newlines"sv;
auto file_wo_newlines = Core::File::open(filename, Core::File::OpenMode::Write).release_value();
EXPECT(!file_wo_newlines->write_until_depleted(new_newlines_message.bytes()).is_error());
TRY_OR_FAIL(file_wo_newlines->write_until_depleted(new_newlines_message.bytes()));
file_wo_newlines->close();
auto ro_file = Core::InputBufferedFile::create(Core::File::open(filename, Core::File::OpenMode::Read).release_value(), new_newlines_message.length() + 1).release_value();
auto maybe_can_read_line = ro_file->can_read_line();
EXPECT(!maybe_can_read_line.is_error());
EXPECT(maybe_can_read_line.release_value());
auto can_read_line = TRY_OR_FAIL(ro_file->can_read_line());
EXPECT(can_read_line);
Array<u8, new_newlines_message.length() + 1> buffer;
EXPECT(ro_file->read_line(buffer).release_value() == new_newlines_message);
}
@ -579,36 +507,25 @@ TEST_CASE(buffered_tcp_socket_read)
{
Core::EventLoop event_loop;
auto maybe_tcp_server = Core::TCPServer::try_create();
EXPECT(!maybe_tcp_server.is_error());
auto tcp_server = maybe_tcp_server.release_value();
EXPECT(!tcp_server->listen({ 127, 0, 0, 1 }, 9090).is_error());
EXPECT(!tcp_server->set_blocking(true).is_error());
auto tcp_server = TRY_OR_FAIL(Core::TCPServer::try_create());
TRY_OR_FAIL(tcp_server->listen({ 127, 0, 0, 1 }, 9090));
TRY_OR_FAIL(tcp_server->set_blocking(true));
auto maybe_client_socket = Core::TCPSocket::connect({ { 127, 0, 0, 1 }, 9090 });
EXPECT(!maybe_client_socket.is_error());
auto maybe_buffered_socket = Core::BufferedTCPSocket::create(maybe_client_socket.release_value());
EXPECT(!maybe_buffered_socket.is_error());
auto client_socket = maybe_buffered_socket.release_value();
auto unbuffered_socket = TRY_OR_FAIL(Core::TCPSocket::connect({ { 127, 0, 0, 1 }, 9090 }));
auto client_socket = TRY_OR_FAIL(Core::BufferedTCPSocket::create(move(unbuffered_socket)));
EXPECT(client_socket->is_open());
auto maybe_server_socket = tcp_server->accept();
EXPECT(!maybe_server_socket.is_error());
auto server_socket = maybe_server_socket.release_value();
EXPECT(!server_socket->write_some({ buffered_sent_data.characters_without_null_termination(), sent_data.length() }).is_error());
auto server_socket = TRY_OR_FAIL(tcp_server->accept());
TRY_OR_FAIL(server_socket->write_some({ buffered_sent_data.characters_without_null_termination(), sent_data.length() }));
EXPECT(client_socket->can_read_without_blocking(100).release_value());
auto receive_buffer = ByteBuffer::create_uninitialized(64).release_value();
auto maybe_first_received_line = client_socket->read_line(receive_buffer);
EXPECT(!maybe_first_received_line.is_error());
auto first_received_line = maybe_first_received_line.value();
auto first_received_line = TRY_OR_FAIL(client_socket->read_line(receive_buffer));
EXPECT_EQ(first_received_line, first_line);
auto maybe_second_received_line = client_socket->read_line(receive_buffer);
EXPECT(!maybe_second_received_line.is_error());
auto second_received_line = maybe_second_received_line.value();
auto second_received_line = TRY_OR_FAIL(client_socket->read_line(receive_buffer));
EXPECT_EQ(second_received_line, second_line);
}