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

LibCore+Userland+Tests: Convert Stream APIs to construct on heap

Browse source 
As per previous discussion, it was decided that the Stream classes
should be constructed on the heap.

While I don't personally agree with this change, it does have the
benefit of avoiding Function object reconstructions due to the lambda
passed to Notifier pointing to a stale object reference. This also has
the benefit of not having to "box" objects for virtual usage, as the
objects come pre-boxed.

However, it means that we now hit the heap everytime we construct a
TCPSocket for instance, which might not be desirable.
This commit is contained in:
sin-ack 2021-12-29 22:31:45 +00:00 • committed by Ali Mohammad Pur
parent eb389db92c
commit dbd25916a3
14 changed files with 163 additions and 162 deletions
Download patch file Download diff file Expand all files Collapse all files

126
Tests/LibCore/TestLibCoreStream.cpp
View file

@ -31,12 +31,12 @@ TEST_CASE(file_open)
// Testing out some basic file properties.
auto file = maybe_file.release_value();
EXPECT(file.is_open());
EXPECT(!file.is_readable());
EXPECT(file.is_writable());
EXPECT(!file.is_eof());
EXPECT(file->is_open());
EXPECT(!file->is_readable());
EXPECT(file->is_writable());
EXPECT(!file->is_eof());
auto maybe_size = file.size();
auto maybe_size = file->size();
EXPECT(!maybe_size.is_error());
EXPECT_EQ(maybe_size.value(), 0);
}
@ -48,7 +48,7 @@ TEST_CASE(file_write_bytes)
constexpr auto some_words = "These are some words"sv;
ReadonlyBytes buffer { some_words.characters_without_null_termination(), some_words.length() };
auto result = file.write(buffer);
auto result = file->write(buffer);
EXPECT(!result.is_error());
}
@ -64,7 +64,7 @@ TEST_CASE(file_read_bytes)
EXPECT(maybe_buffer.has_value());
auto buffer = maybe_buffer.release_value();
auto result = file.read(buffer);
auto result = file->read(buffer);
EXPECT(!result.is_error());
EXPECT_EQ(result.value(), 131ul);
@ -82,7 +82,7 @@ TEST_CASE(file_seeking_around)
EXPECT(!maybe_file.is_error());
auto file = maybe_file.release_value();
EXPECT_EQ(file.size().release_value(), 8702);
EXPECT_EQ(file->size().release_value(), 8702);
auto maybe_buffer = ByteBuffer::create_uninitialized(16);
EXPECT(maybe_buffer.has_value());
@ -90,19 +90,19 @@ TEST_CASE(file_seeking_around)
StringView buffer_contents { buffer.bytes() };
EXPECT(!file.seek(500, Core::Stream::SeekMode::SetPosition).is_error());
EXPECT_EQ(file.tell().release_value(), 500);
EXPECT(file.read_or_error(buffer));
EXPECT(!file->seek(500, Core::Stream::SeekMode::SetPosition).is_error());
EXPECT_EQ(file->tell().release_value(), 500);
EXPECT(file->read_or_error(buffer));
EXPECT_EQ(buffer_contents, expected_seek_contents1);
EXPECT(!file.seek(234, Core::Stream::SeekMode::FromCurrentPosition).is_error());
EXPECT_EQ(file.tell().release_value(), 750);
EXPECT(file.read_or_error(buffer));
EXPECT(!file->seek(234, Core::Stream::SeekMode::FromCurrentPosition).is_error());
EXPECT_EQ(file->tell().release_value(), 750);
EXPECT(file->read_or_error(buffer));
EXPECT_EQ(buffer_contents, expected_seek_contents2);
EXPECT(!file.seek(-105, Core::Stream::SeekMode::FromEndPosition).is_error());
EXPECT_EQ(file.tell().release_value(), 8597);
EXPECT(file.read_or_error(buffer));
EXPECT(!file->seek(-105, Core::Stream::SeekMode::FromEndPosition).is_error());
EXPECT_EQ(file->tell().release_value(), 8597);
EXPECT(file->read_or_error(buffer));
EXPECT_EQ(buffer_contents, expected_seek_contents3);
}
@ -115,7 +115,7 @@ TEST_CASE(file_adopt_fd)
EXPECT(!maybe_file.is_error());
auto file = maybe_file.release_value();
EXPECT_EQ(file.size().release_value(), 8702);
EXPECT_EQ(file->size().release_value(), 8702);
auto maybe_buffer = ByteBuffer::create_uninitialized(16);
EXPECT(maybe_buffer.has_value());
@ -123,9 +123,9 @@ TEST_CASE(file_adopt_fd)
StringView buffer_contents { buffer.bytes() };
EXPECT(!file.seek(500, Core::Stream::SeekMode::SetPosition).is_error());
EXPECT_EQ(file.tell().release_value(), 500);
EXPECT(file.read_or_error(buffer));
EXPECT(!file->seek(500, Core::Stream::SeekMode::SetPosition).is_error());
EXPECT_EQ(file->tell().release_value(), 500);
EXPECT(file->read_or_error(buffer));
EXPECT_EQ(buffer_contents, expected_seek_contents1);
// A single seek & read test should be fine for now.
@ -158,20 +158,20 @@ TEST_CASE(tcp_socket_read)
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
EXPECT(client_socket.is_open());
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({ sent_data.characters_without_null_termination(), sent_data.length() }).is_error());
server_socket.close();
EXPECT(!server_socket->write({ sent_data.characters_without_null_termination(), sent_data.length() }).is_error());
server_socket->close();
EXPECT(client_socket.can_read_without_blocking(100).release_value());
EXPECT_EQ(client_socket.pending_bytes().release_value(), sent_data.length());
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);
auto receive_buffer = maybe_receive_buffer.release_value();
auto maybe_nread = client_socket.read(receive_buffer);
auto maybe_nread = client_socket->read(receive_buffer);
EXPECT(!maybe_nread.is_error());
auto nread = maybe_nread.release_value();
@ -196,13 +196,13 @@ TEST_CASE(tcp_socket_write)
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());
EXPECT(!server_socket->set_blocking(true).is_error());
EXPECT(client_socket.write_or_error({ sent_data.characters_without_null_termination(), sent_data.length() }));
client_socket.close();
EXPECT(client_socket->write_or_error({ sent_data.characters_without_null_termination(), sent_data.length() }));
client_socket->close();
auto receive_buffer = ByteBuffer::create_uninitialized(64).release_value();
auto maybe_nread = server_socket.read(receive_buffer);
auto maybe_nread = server_socket->read(receive_buffer);
EXPECT(!maybe_nread.is_error());
auto nread = maybe_nread.release_value();
@ -224,21 +224,21 @@ TEST_CASE(tcp_socket_eof)
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
EXPECT(client_socket.is_open());
EXPECT(client_socket->is_open());
auto server_socket = tcp_server->accept().release_value();
server_socket.close();
server_socket->close();
// NOTE: This may seem unintuitive, but poll will mark a fd which has
// reached EOF (i.e. in the case of the other side disconnecting) as
// POLLIN.
EXPECT(client_socket.can_read_without_blocking(100).release_value());
EXPECT_EQ(client_socket.pending_bytes().release_value(), 0ul);
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);
auto receive_buffer = maybe_receive_buffer.release_value();
EXPECT_EQ(client_socket.read(receive_buffer).release_value(), 0ul);
EXPECT(client_socket.is_eof());
EXPECT_EQ(client_socket->read(receive_buffer).release_value(), 0ul);
EXPECT(client_socket->is_eof());
}
// UDPSocket tests
@ -258,8 +258,8 @@ TEST_CASE(udp_socket_read_write)
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
EXPECT(client_socket.is_open());
EXPECT(client_socket.write_or_error({ sent_data.characters_without_null_termination(), sent_data.length() }));
EXPECT(client_socket->is_open());
EXPECT(client_socket->write_or_error({ sent_data.characters_without_null_termination(), sent_data.length() }));
// FIXME: UDPServer::receive sadly doesn't give us a way to block on it,
// currently.
@ -274,16 +274,16 @@ TEST_CASE(udp_socket_read_write)
EXPECT(!udp_server->send({ udp_reply_data.characters_without_null_termination(), udp_reply_data.length() }, client_address).is_error());
EXPECT(client_socket.can_read_without_blocking(100).release_value());
EXPECT_EQ(client_socket.pending_bytes().release_value(), udp_reply_data.length());
EXPECT(client_socket->can_read_without_blocking(100).release_value());
EXPECT_EQ(client_socket->pending_bytes().release_value(), udp_reply_data.length());
// Testing that supplying a smaller buffer than required causes a failure.
auto small_buffer = ByteBuffer::create_uninitialized(8).release_value();
EXPECT_EQ(client_socket.read(small_buffer).error().code(), EMSGSIZE);
EXPECT_EQ(client_socket->read(small_buffer).error().code(), EMSGSIZE);
auto maybe_client_receive_buffer = ByteBuffer::create_uninitialized(64);
auto client_receive_buffer = maybe_client_receive_buffer.release_value();
auto maybe_nread = client_socket.read(client_receive_buffer);
auto maybe_nread = client_socket->read(client_receive_buffer);
EXPECT(!maybe_nread.is_error());
auto nread = maybe_nread.release_value();
@ -317,14 +317,14 @@ TEST_CASE(local_socket_read)
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
EXPECT(client_socket.is_open());
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());
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);
auto receive_buffer = maybe_receive_buffer.release_value();
auto maybe_nread = client_socket.read(receive_buffer);
auto maybe_nread = client_socket->read(receive_buffer);
EXPECT(!maybe_nread.is_error());
auto nread = maybe_nread.release_value();
@ -367,8 +367,8 @@ TEST_CASE(local_socket_write)
EXPECT(!maybe_client_socket.is_error());
auto client_socket = maybe_client_socket.release_value();
EXPECT(client_socket.write_or_error({ sent_data.characters_without_null_termination(), sent_data.length() }));
client_socket.close();
EXPECT(client_socket->write_or_error({ sent_data.characters_without_null_termination(), sent_data.length() }));
client_socket->close();
return 0;
},
@ -389,15 +389,15 @@ TEST_CASE(buffered_long_file_read)
auto file = maybe_buffered_file.release_value();
auto buffer = ByteBuffer::create_uninitialized(4096).release_value();
EXPECT(!file.seek(255, Core::Stream::SeekMode::SetPosition).is_error());
EXPECT(file.can_read_line().release_value());
auto maybe_nread = file.read_line(buffer);
EXPECT(!file->seek(255, Core::Stream::SeekMode::SetPosition).is_error());
EXPECT(file->can_read_line().release_value());
auto maybe_nread = file->read_line(buffer);
EXPECT(!maybe_nread.is_error());
EXPECT_EQ(maybe_nread.value(), 4095ul); // 4095 bytes on the third line
// Testing that buffering with seeking works properly
EXPECT(!file.seek(365, Core::Stream::SeekMode::SetPosition).is_error());
auto maybe_after_seek_nread = file.read_line(buffer);
EXPECT(!file->seek(365, Core::Stream::SeekMode::SetPosition).is_error());
auto maybe_after_seek_nread = file->read_line(buffer);
EXPECT(!maybe_after_seek_nread.is_error());
EXPECT_EQ(maybe_after_seek_nread.value(), 3985ul); // 4095 - 110
}
@ -420,14 +420,14 @@ TEST_CASE(buffered_small_file_read)
// Testing that we don't read out of bounds when the entire file fits into the buffer
auto buffer = ByteBuffer::create_uninitialized(4096).release_value();
for (auto const& line : expected_lines) {
VERIFY(file.can_read_line().release_value());
auto maybe_nread = file.read_line(buffer);
VERIFY(file->can_read_line().release_value());
auto maybe_nread = file->read_line(buffer);
EXPECT(!maybe_nread.is_error());
EXPECT_EQ(maybe_nread.value(), line.length());
EXPECT_EQ(StringView(buffer.span().trim(maybe_nread.value())), line);
}
EXPECT(!file.can_read_line().is_error());
EXPECT(!file.can_read_line().value());
EXPECT(!file->can_read_line().is_error());
EXPECT(!file->can_read_line().value());
}
constexpr auto buffered_sent_data = "Well hello friends!\n:^)\nThis shouldn't be present. :^("sv;
@ -450,23 +450,23 @@ TEST_CASE(buffered_tcp_socket_read)
EXPECT(!maybe_buffered_socket.is_error());
auto client_socket = maybe_buffered_socket.release_value();
EXPECT(client_socket.is_open());
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({ buffered_sent_data.characters_without_null_termination(), sent_data.length() }).is_error());
EXPECT(!server_socket->write({ buffered_sent_data.characters_without_null_termination(), sent_data.length() }).is_error());
EXPECT(client_socket.can_read_without_blocking(100).release_value());
EXPECT(client_socket->can_read_without_blocking(100).release_value());
auto receive_buffer = ByteBuffer::create_uninitialized(64).release_value();
auto maybe_first_nread = client_socket.read_line(receive_buffer);
auto maybe_first_nread = client_socket->read_line(receive_buffer);
EXPECT(!maybe_first_nread.is_error());
StringView first_received_line { receive_buffer.data(), maybe_first_nread.value() };
EXPECT_EQ(first_received_line, first_line);
auto maybe_second_nread = client_socket.read_line(receive_buffer);
auto maybe_second_nread = client_socket->read_line(receive_buffer);
EXPECT(!maybe_second_nread.is_error());
StringView second_received_line { receive_buffer.data(), maybe_second_nread.value() };
EXPECT_EQ(second_received_line, second_line);