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

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

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

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

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

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