RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-10-31 13:42:44 +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

4
Tests/AK/TestBase64.cpp
View file

@ -13,9 +13,7 @@
TEST_CASE(test_decode)
{
auto decode_equal = [&](StringView input, StringView expected) {
auto decoded_option = decode_base64(input);
EXPECT(!decoded_option.is_error());
auto decoded = decoded_option.release_value();
auto decoded = TRY_OR_FAIL(decode_base64(input));
EXPECT(DeprecatedString::copy(decoded) == expected);
EXPECT(expected.length() <= calculate_base64_decoded_length(input.bytes()));
};

40
Tests/AK/TestCircularBuffer.cpp
View file

@ -12,10 +12,7 @@ namespace {
CircularBuffer create_circular_buffer(size_t size)
{
auto buffer_or_error = CircularBuffer::create_empty(size);
EXPECT(!buffer_or_error.is_error());
return buffer_or_error.release_value();
return MUST(CircularBuffer::create_empty(size));
}
void safe_write(CircularBuffer& buffer, u8 i)
@ -36,8 +33,7 @@ void safe_read(CircularBuffer& buffer, u8 supposed_result)
void safe_discard(CircularBuffer& buffer, size_t size)
{
auto result = buffer.discard(size);
EXPECT(!result.is_error());
TRY_OR_FAIL(buffer.discard(size));
};
}
@ -177,13 +173,9 @@ TEST_CASE(full_write_non_aligned)
TEST_CASE(create_from_bytebuffer)
{
u8 const source[] = { 2, 4, 6 };
auto byte_buffer_or_error = ByteBuffer::copy(source, AK::array_size(source));
EXPECT(!byte_buffer_or_error.is_error());
auto byte_buffer = byte_buffer_or_error.release_value();
auto byte_buffer = TRY_OR_FAIL(ByteBuffer::copy(source, AK::array_size(source)));
auto circular_buffer_or_error = CircularBuffer::create_initialized(move(byte_buffer));
EXPECT(!circular_buffer_or_error.is_error());
auto circular_buffer = circular_buffer_or_error.release_value();
auto circular_buffer = TRY_OR_FAIL(CircularBuffer::create_initialized(move(byte_buffer)));
EXPECT_EQ(circular_buffer.used_space(), circular_buffer.capacity());
EXPECT_EQ(circular_buffer.used_space(), 3ul);
@ -247,13 +239,9 @@ TEST_CASE(discard_too_much)
TEST_CASE(offset_of)
{
auto const source = "Well Hello Friends!"sv;
auto byte_buffer_or_error = ByteBuffer::copy(source.bytes());
EXPECT(!byte_buffer_or_error.is_error());
auto byte_buffer = byte_buffer_or_error.release_value();
auto byte_buffer = TRY_OR_FAIL(ByteBuffer::copy(source.bytes()));
auto circular_buffer_or_error = CircularBuffer::create_initialized(byte_buffer);
EXPECT(!circular_buffer_or_error.is_error());
auto circular_buffer = circular_buffer_or_error.release_value();
auto circular_buffer = TRY_OR_FAIL(CircularBuffer::create_initialized(byte_buffer));
auto result = circular_buffer.offset_of("Well"sv);
EXPECT(result.has_value());
@ -283,13 +271,9 @@ TEST_CASE(offset_of)
TEST_CASE(offset_of_with_until_and_after)
{
auto const source = "Well Hello Friends!"sv;
auto byte_buffer_or_error = ByteBuffer::copy(source.bytes());
EXPECT(!byte_buffer_or_error.is_error());
auto byte_buffer = byte_buffer_or_error.release_value();
auto byte_buffer = TRY_OR_FAIL(ByteBuffer::copy(source.bytes()));
auto circular_buffer_or_error = CircularBuffer::create_initialized(byte_buffer);
EXPECT(!circular_buffer_or_error.is_error());
auto circular_buffer = circular_buffer_or_error.release_value();
auto circular_buffer = TRY_OR_FAIL(CircularBuffer::create_initialized(byte_buffer));
auto result = circular_buffer.offset_of("Well Hello Friends!"sv, 0, 19);
EXPECT_EQ(result.value_or(42), 0ul);
@ -317,13 +301,9 @@ TEST_CASE(offset_of_with_until_and_after)
TEST_CASE(offset_of_with_until_and_after_wrapping_around)
{
auto const source = "Well Hello Friends!"sv;
auto byte_buffer_or_error = ByteBuffer::copy(source.bytes());
EXPECT(!byte_buffer_or_error.is_error());
auto byte_buffer = byte_buffer_or_error.release_value();
auto byte_buffer = TRY_OR_FAIL(ByteBuffer::copy(source.bytes()));
auto circular_buffer_or_error = CircularBuffer::create_empty(19);
EXPECT(!circular_buffer_or_error.is_error());
auto circular_buffer = circular_buffer_or_error.release_value();
auto circular_buffer = TRY_OR_FAIL(CircularBuffer::create_empty(19));
auto written_bytes = circular_buffer.write(byte_buffer.span().trim(5));
EXPECT_EQ(written_bytes, 5ul);

5
Tests/Kernel/TestKernelFilePermissions.cpp
View file

@ -81,10 +81,9 @@ TEST_CASE(test_change_file_location)
ftruncate(fd, 0);
EXPECT(fchmod(fd, 06755) != -1);
auto suid_path_or_error = FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd));
EXPECT(!suid_path_or_error.is_error());
auto suid_path_string = TRY_OR_FAIL(FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd)));
auto suid_path = suid_path_or_error.release_value().to_deprecated_string();
auto suid_path = suid_path_string.to_deprecated_string();
EXPECT(suid_path.characters());
auto new_path = DeprecatedString::formatted("{}.renamed", suid_path);

5
Tests/LibC/TestIo.cpp
View file

@ -217,10 +217,7 @@ TEST_CASE(unlink_symlink)
perror("symlink");
}
auto target_or_error = FileSystem::read_link("/tmp/linky"sv);
EXPECT(!target_or_error.is_error());
auto target = target_or_error.release_value();
auto target = TRY_OR_FAIL(FileSystem::read_link("/tmp/linky"sv));
EXPECT_EQ(target.bytes_as_string_view(), "/proc/2/foo"sv);
rc = unlink("/tmp/linky");

24
Tests/LibC/TestLibCMkTemp.cpp
View file

@ -86,10 +86,8 @@ TEST_CASE(test_mkstemp_unique_filename)
auto fd = mkstemp(path);
EXPECT_NE(fd, -1);
auto temp_path_or_error = FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd));
EXPECT(!temp_path_or_error.is_error());
auto temp_path = temp_path_or_error.release_value().to_deprecated_string();
auto temp_path_string = TRY_OR_FAIL(FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd)));
auto temp_path = temp_path_string.to_deprecated_string();
EXPECT(temp_path.characters());
close(fd);
@ -107,10 +105,8 @@ TEST_CASE(test_mkstemp_unique_filename)
auto fd = mkstemp(path);
EXPECT(fd != -1);
auto path2_or_error = FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd));
EXPECT(!path2_or_error.is_error());
auto path2 = path2_or_error.release_value().to_deprecated_string();
auto path2_string = TRY_OR_FAIL(FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd)));
auto path2 = path2_string.to_deprecated_string();
EXPECT(path2.characters());
close(fd);
@ -132,10 +128,8 @@ TEST_CASE(test_mkstemps_unique_filename)
auto fd = mkstemps(path, 6);
EXPECT_NE(fd, -1);
auto temp_path_or_error = FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd));
EXPECT(!temp_path_or_error.is_error());
auto temp_path = temp_path_or_error.release_value().to_deprecated_string();
auto temp_path_string = TRY_OR_FAIL(FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd)));
auto temp_path = temp_path_string.to_deprecated_string();
EXPECT(temp_path.characters());
close(fd);
@ -157,10 +151,8 @@ TEST_CASE(test_mkstemps_unique_filename)
auto fd = mkstemps(path, 6);
EXPECT(fd != -1);
auto path2_or_error = FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd));
EXPECT(!path2_or_error.is_error());
auto path2 = path2_or_error.release_value().to_deprecated_string();
auto path2_string = TRY_OR_FAIL(FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd)));
auto path2 = path2_string.to_deprecated_string();
EXPECT(path2.characters());
close(fd);

27
Tests/LibCompress/TestDeflate.cpp
View file

@ -116,11 +116,9 @@ TEST_CASE(deflate_round_trip_store)
{
auto original = ByteBuffer::create_uninitialized(1024).release_value();
fill_with_random(original);
auto compressed = Compress::DeflateCompressor::compress_all(original, Compress::DeflateCompressor::CompressionLevel::STORE);
EXPECT(!compressed.is_error());
auto uncompressed = Compress::DeflateDecompressor::decompress_all(compressed.value());
EXPECT(!uncompressed.is_error());
EXPECT(uncompressed.value() == original);
auto compressed = TRY_OR_FAIL(Compress::DeflateCompressor::compress_all(original, Compress::DeflateCompressor::CompressionLevel::STORE));
auto uncompressed = TRY_OR_FAIL(Compress::DeflateDecompressor::decompress_all(compressed));
EXPECT(uncompressed == original);
}
TEST_CASE(deflate_round_trip_compress)
@ -128,11 +126,9 @@ TEST_CASE(deflate_round_trip_compress)
auto original = ByteBuffer::create_zeroed(2048).release_value();
fill_with_random(original.bytes().trim(1024)); // we pre-filled the second half with 0s to make sure we test back references as well
// Since the different levels just change how much time is spent looking for better matches, just use fast here to reduce test time
auto compressed = Compress::DeflateCompressor::compress_all(original, Compress::DeflateCompressor::CompressionLevel::FAST);
EXPECT(!compressed.is_error());
auto uncompressed = Compress::DeflateDecompressor::decompress_all(compressed.value());
EXPECT(!uncompressed.is_error());
EXPECT(uncompressed.value() == original);
auto compressed = TRY_OR_FAIL(Compress::DeflateCompressor::compress_all(original, Compress::DeflateCompressor::CompressionLevel::FAST));
auto uncompressed = TRY_OR_FAIL(Compress::DeflateDecompressor::decompress_all(compressed));
EXPECT(uncompressed == original);
}
TEST_CASE(deflate_round_trip_compress_large)
@ -141,17 +137,14 @@ TEST_CASE(deflate_round_trip_compress_large)
auto original = ByteBuffer::create_uninitialized(size).release_value(); // Compress a buffer larger than the maximum block size to test the sliding window mechanism
fill_with_random(original);
// Since the different levels just change how much time is spent looking for better matches, just use fast here to reduce test time
auto compressed = Compress::DeflateCompressor::compress_all(original, Compress::DeflateCompressor::CompressionLevel::FAST);
EXPECT(!compressed.is_error());
auto uncompressed = Compress::DeflateDecompressor::decompress_all(compressed.value());
EXPECT(!uncompressed.is_error());
EXPECT(uncompressed.value() == original);
auto compressed = TRY_OR_FAIL(Compress::DeflateCompressor::compress_all(original, Compress::DeflateCompressor::CompressionLevel::FAST));
auto uncompressed = TRY_OR_FAIL(Compress::DeflateDecompressor::decompress_all(compressed));
EXPECT(uncompressed == original);
}
TEST_CASE(deflate_compress_literals)
{
// This byte array is known to not produce any back references with our lz77 implementation even at the highest compression settings
Array<u8, 0x13> test { 0, 0, 0, 0, 0x72, 0, 0, 0xee, 0, 0, 0, 0x26, 0, 0, 0, 0x28, 0, 0, 0x72 };
auto compressed = Compress::DeflateCompressor::compress_all(test, Compress::DeflateCompressor::CompressionLevel::GOOD);
EXPECT(!compressed.is_error());
auto compressed = TRY_OR_FAIL(Compress::DeflateCompressor::compress_all(test, Compress::DeflateCompressor::CompressionLevel::GOOD));
}

8
Tests/LibCompress/TestGzip.cpp
View file

@ -89,11 +89,9 @@ TEST_CASE(gzip_round_trip)
{
auto original = ByteBuffer::create_uninitialized(1024).release_value();
fill_with_random(original);
auto compressed = Compress::GzipCompressor::compress_all(original);
EXPECT(!compressed.is_error());
auto uncompressed = Compress::GzipDecompressor::decompress_all(compressed.value());
EXPECT(!uncompressed.is_error());
EXPECT(uncompressed.value() == original);
auto compressed = TRY_OR_FAIL(Compress::GzipCompressor::compress_all(original));
auto uncompressed = TRY_OR_FAIL(Compress::GzipDecompressor::decompress_all(compressed));
EXPECT(uncompressed == original);
}
TEST_CASE(gzip_truncated_uncompressed_block)

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

100
Tests/LibEDID/TestEDID.cpp
View file

@ -35,9 +35,7 @@ static const u8 edid1_bin[] = {
TEST_CASE(edid1)
{
auto edid_load_result = EDID::Parser::from_bytes({ edid1_bin, sizeof(edid1_bin) });
EXPECT(!edid_load_result.is_error());
auto edid = edid_load_result.release_value();
auto edid = TRY_OR_FAIL(EDID::Parser::from_bytes({ edid1_bin, sizeof(edid1_bin) }));
EXPECT(edid.legacy_manufacturer_id() == "RHT");
EXPECT(!edid.aspect_ratio().has_value());
auto screen_size = edid.screen_size();
@ -69,7 +67,7 @@ TEST_CASE(edid1)
};
static constexpr size_t expected_established_timings_count = sizeof(expected_established_timings) / sizeof(expected_established_timings[0]);
size_t established_timings_found = 0;
auto result = edid.for_each_established_timing([&](auto& established_timings) {
auto result = TRY_OR_FAIL(edid.for_each_established_timing([&](auto& established_timings) {
EXPECT(established_timings_found < expected_established_timings_count);
auto& expected_timings = expected_established_timings[established_timings_found];
EXPECT(established_timings.width() == expected_timings.width);
@ -79,9 +77,8 @@ TEST_CASE(edid1)
EXPECT(established_timings.dmt_id() == expected_timings.dmt_id);
established_timings_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(established_timings_found == expected_established_timings_count);
}
@ -103,7 +100,7 @@ TEST_CASE(edid1)
};
static constexpr size_t expected_standard_timings_count = sizeof(expected_standard_established_timings) / sizeof(expected_standard_established_timings[0]);
size_t standard_timings_found = 0;
auto result = edid.for_each_standard_timing([&](auto& standard_timings) {
auto result = TRY_OR_FAIL(edid.for_each_standard_timing([&](auto& standard_timings) {
EXPECT(standard_timings_found < expected_standard_timings_count);
auto& expected_timings = expected_standard_established_timings[standard_timings_found];
EXPECT(standard_timings.dmt_id() == expected_timings.dmt_id);
@ -112,9 +109,8 @@ TEST_CASE(edid1)
EXPECT(standard_timings.refresh_rate() == expected_timings.refresh_rate);
standard_timings_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(standard_timings_found == expected_standard_timings_count);
}
@ -129,7 +125,7 @@ TEST_CASE(edid1)
};
static constexpr size_t expected_detailed_timings_count = sizeof(expected_detailed_timings) / sizeof(expected_detailed_timings[0]);
size_t detailed_timings_found = 0;
auto result = edid.for_each_detailed_timing([&](auto& detailed_timing, unsigned block_id) {
auto result = TRY_OR_FAIL(edid.for_each_detailed_timing([&](auto& detailed_timing, unsigned block_id) {
EXPECT(detailed_timings_found < expected_detailed_timings_count);
auto& expected_timings = expected_detailed_timings[detailed_timings_found];
EXPECT(block_id == expected_timings.block_id);
@ -138,9 +134,8 @@ TEST_CASE(edid1)
EXPECT(detailed_timing.refresh_rate().lround() == expected_timings.refresh_rate);
detailed_timings_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(detailed_timings_found == expected_detailed_timings_count);
}
@ -148,31 +143,29 @@ TEST_CASE(edid1)
static constexpr u8 expected_vic_ids[] = { 125, 101, 96, 89, 31 };
static constexpr size_t expected_vic_ids_count = sizeof(expected_vic_ids) / sizeof(expected_vic_ids[0]);
size_t vic_ids_found = 0;
auto result = edid.for_each_short_video_descriptor([&](unsigned block_id, bool is_native, EDID::VIC::Details const& vic) {
auto result = TRY_OR_FAIL(edid.for_each_short_video_descriptor([&](unsigned block_id, bool is_native, EDID::VIC::Details const& vic) {
EXPECT(vic_ids_found < expected_vic_ids_count);
EXPECT(block_id == 1);
EXPECT(!is_native); // none are marked as native
EXPECT(vic.vic_id == expected_vic_ids[vic_ids_found]);
vic_ids_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(vic_ids_found == expected_vic_ids_count);
}
{
// This edid has one CEA861 extension block only
size_t extension_blocks_found = 0;
auto result = edid.for_each_extension_block([&](unsigned block_id, u8 tag, u8 revision, ReadonlyBytes) {
auto result = TRY_OR_FAIL(edid.for_each_extension_block([&](unsigned block_id, u8 tag, u8 revision, ReadonlyBytes) {
EXPECT(block_id == 1);
EXPECT(tag == 0x2);
EXPECT(revision == 3);
extension_blocks_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(extension_blocks_found == 1);
}
}
@ -204,9 +197,7 @@ static const u8 edid2_bin[] = {
TEST_CASE(edid2)
{
auto edid_load_result = EDID::Parser::from_bytes({ edid2_bin, sizeof(edid2_bin) });
EXPECT(!edid_load_result.is_error());
auto edid = edid_load_result.release_value();
auto edid = TRY_OR_FAIL(EDID::Parser::from_bytes({ edid2_bin, sizeof(edid2_bin) }));
EXPECT(edid.legacy_manufacturer_id() == "ACR");
EXPECT(edid.serial_number() == 1234567890);
auto digital_interface = edid.digital_display();
@ -256,7 +247,7 @@ TEST_CASE(edid2)
};
static constexpr size_t expected_established_timings_count = sizeof(expected_established_timings) / sizeof(expected_established_timings[0]);
size_t established_timings_found = 0;
auto result = edid.for_each_established_timing([&](auto& established_timings) {
auto result = TRY_OR_FAIL(edid.for_each_established_timing([&](auto& established_timings) {
EXPECT(established_timings_found < expected_established_timings_count);
auto& expected_timings = expected_established_timings[established_timings_found];
EXPECT(established_timings.width() == expected_timings.width);
@ -266,9 +257,8 @@ TEST_CASE(edid2)
EXPECT(established_timings.dmt_id() == expected_timings.dmt_id);
established_timings_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(established_timings_found == expected_established_timings_count);
}
@ -288,7 +278,7 @@ TEST_CASE(edid2)
};
static constexpr size_t expected_standard_timings_count = sizeof(expected_standard_established_timings) / sizeof(expected_standard_established_timings[0]);
size_t standard_timings_found = 0;
auto result = edid.for_each_standard_timing([&](auto& standard_timings) {
auto result = TRY_OR_FAIL(edid.for_each_standard_timing([&](auto& standard_timings) {
EXPECT(standard_timings_found < expected_standard_timings_count);
auto& expected_timings = expected_standard_established_timings[standard_timings_found];
EXPECT(standard_timings.dmt_id() == expected_timings.dmt_id);
@ -297,9 +287,8 @@ TEST_CASE(edid2)
EXPECT(standard_timings.refresh_rate() == expected_timings.refresh_rate);
standard_timings_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(standard_timings_found == expected_standard_timings_count);
}
@ -318,7 +307,7 @@ TEST_CASE(edid2)
};
static constexpr size_t expected_detailed_timings_count = sizeof(expected_detailed_timings) / sizeof(expected_detailed_timings[0]);
size_t detailed_timings_found = 0;
auto result = edid.for_each_detailed_timing([&](auto& detailed_timing, unsigned block_id) {
auto result = TRY_OR_FAIL(edid.for_each_detailed_timing([&](auto& detailed_timing, unsigned block_id) {
EXPECT(detailed_timings_found < expected_detailed_timings_count);
auto& expected_timings = expected_detailed_timings[detailed_timings_found];
EXPECT(block_id == expected_timings.block_id);
@ -327,9 +316,8 @@ TEST_CASE(edid2)
EXPECT(detailed_timing.refresh_rate().lround() == expected_timings.refresh_rate);
detailed_timings_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(detailed_timings_found == expected_detailed_timings_count);
}
@ -337,31 +325,29 @@ TEST_CASE(edid2)
static constexpr u8 expected_vic_ids[] = { 18, 19, 4, 31, 16, 20, 5, 1, 17, 2, 3, 74 };
static constexpr size_t expected_vic_ids_count = sizeof(expected_vic_ids) / sizeof(expected_vic_ids[0]);
size_t vic_ids_found = 0;
auto result = edid.for_each_short_video_descriptor([&](unsigned block_id, bool is_native, EDID::VIC::Details const& vic) {
auto result = TRY_OR_FAIL(edid.for_each_short_video_descriptor([&](unsigned block_id, bool is_native, EDID::VIC::Details const& vic) {
EXPECT(vic_ids_found < expected_vic_ids_count);
EXPECT(block_id == 1);
EXPECT(is_native == (vic_ids_found == 4)); // the 5th value is marked native
EXPECT(vic.vic_id == expected_vic_ids[vic_ids_found]);
vic_ids_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(vic_ids_found == expected_vic_ids_count);
}
{
// This edid has one CEA861 extension block only
size_t extension_blocks_found = 0;
auto result = edid.for_each_extension_block([&](unsigned block_id, u8 tag, u8 revision, ReadonlyBytes) {
auto result = TRY_OR_FAIL(edid.for_each_extension_block([&](unsigned block_id, u8 tag, u8 revision, ReadonlyBytes) {
EXPECT(block_id == 1);
EXPECT(tag == 0x2);
EXPECT(revision == 3);
extension_blocks_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(extension_blocks_found == 1);
}
}
@ -415,9 +401,7 @@ static const u8 edid_extension_maps[] = {
TEST_CASE(edid_extension_maps)
{
auto edid_load_result = EDID::Parser::from_bytes({ edid_extension_maps, sizeof(edid_extension_maps) });
EXPECT(!edid_load_result.is_error());
auto edid = edid_load_result.release_value();
auto edid = TRY_OR_FAIL(EDID::Parser::from_bytes({ edid_extension_maps, sizeof(edid_extension_maps) }));
EXPECT(edid.legacy_manufacturer_id() == "SII");
{
@ -440,7 +424,7 @@ TEST_CASE(edid_extension_maps)
};
static constexpr size_t expected_detailed_timings_count = sizeof(expected_detailed_timings) / sizeof(expected_detailed_timings[0]);
size_t detailed_timings_found = 0;
auto result = edid.for_each_detailed_timing([&](auto& detailed_timing, unsigned block_id) {
auto result = TRY_OR_FAIL(edid.for_each_detailed_timing([&](auto& detailed_timing, unsigned block_id) {
EXPECT(detailed_timings_found < expected_detailed_timings_count);
auto& expected_timings = expected_detailed_timings[detailed_timings_found];
EXPECT(block_id == expected_timings.block_id);
@ -449,9 +433,8 @@ TEST_CASE(edid_extension_maps)
EXPECT(detailed_timing.refresh_rate().lround() == expected_timings.refresh_rate);
detailed_timings_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(detailed_timings_found == expected_detailed_timings_count);
}
}
@ -472,9 +455,7 @@ static const u8 edid_1_0[] = {
TEST_CASE(edid_1_0)
{
auto edid_load_result = EDID::Parser::from_bytes({ edid_1_0, sizeof(edid_1_0) });
EXPECT(!edid_load_result.is_error());
auto edid = edid_load_result.release_value();
auto edid = TRY_OR_FAIL(EDID::Parser::from_bytes({ edid_1_0, sizeof(edid_1_0) }));
EXPECT(edid.legacy_manufacturer_id() == "MAX");
EXPECT(edid.serial_number() == 123);
@ -492,7 +473,7 @@ TEST_CASE(edid_1_0)
};
static constexpr size_t expected_detailed_timings_count = sizeof(expected_detailed_timings) / sizeof(expected_detailed_timings[0]);
size_t detailed_timings_found = 0;
auto result = edid.for_each_detailed_timing([&](auto& detailed_timing, unsigned block_id) {
auto result = TRY_OR_FAIL(edid.for_each_detailed_timing([&](auto& detailed_timing, unsigned block_id) {
EXPECT(detailed_timings_found < expected_detailed_timings_count);
auto& expected_timings = expected_detailed_timings[detailed_timings_found];
EXPECT(block_id == expected_timings.block_id);
@ -501,9 +482,8 @@ TEST_CASE(edid_1_0)
EXPECT(detailed_timing.refresh_rate().lround() == expected_timings.refresh_rate);
detailed_timings_found++;
return IterationDecision::Continue;
});
EXPECT(!result.is_error());
EXPECT(result.value() == IterationDecision::Continue);
}));
EXPECT(result == IterationDecision::Continue);
EXPECT(detailed_timings_found == expected_detailed_timings_count);
}
}

30
Tests/LibELF/test-elf.cpp
View file

@ -58,10 +58,8 @@ TEST_CASE(test_interp_header_tiny_p_filesz)
int nwritten = write(fd, buffer, sizeof(buffer));
EXPECT(nwritten);
auto elf_path_or_error = FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd));
EXPECT(!elf_path_or_error.is_error());
auto elf_path = elf_path_or_error.release_value().to_deprecated_string();
auto elf_path_string = TRY_OR_FAIL(FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd)));
auto elf_path = elf_path_string.to_deprecated_string();
EXPECT(elf_path.characters());
int rc = execl(elf_path.characters(), "test-elf", nullptr);
@ -115,10 +113,8 @@ TEST_CASE(test_interp_header_p_filesz_larger_than_p_memsz)
int nwritten = write(fd, buffer, sizeof(buffer));
EXPECT(nwritten);
auto elf_path_or_error = FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd));
EXPECT(!elf_path_or_error.is_error());
auto elf_path = elf_path_or_error.release_value().to_deprecated_string();
auto elf_path_string = TRY_OR_FAIL(FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd)));
auto elf_path = elf_path_string.to_deprecated_string();
EXPECT(elf_path.characters());
int rc = execl(elf_path.characters(), "test-elf", nullptr);
@ -176,10 +172,8 @@ TEST_CASE(test_interp_header_p_filesz_plus_p_offset_overflow_p_memsz)
int nwritten = write(fd, buffer, sizeof(buffer));
EXPECT(nwritten);
auto elf_path_or_error = FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd));
EXPECT(!elf_path_or_error.is_error());
auto elf_path = elf_path_or_error.release_value().to_deprecated_string();
auto elf_path_string = TRY_OR_FAIL(FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd)));
auto elf_path = elf_path_string.to_deprecated_string();
EXPECT(elf_path.characters());
int rc = execl(elf_path.characters(), "test-elf", nullptr);
@ -234,10 +228,8 @@ TEST_CASE(test_load_header_p_memsz_zero)
int nwritten = write(fd, buffer, sizeof(buffer));
EXPECT(nwritten);
auto elf_path_or_error = FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd));
EXPECT(!elf_path_or_error.is_error());
auto elf_path = elf_path_or_error.release_value().to_deprecated_string();
auto elf_path_string = TRY_OR_FAIL(FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd)));
auto elf_path = elf_path_string.to_deprecated_string();
EXPECT(elf_path.characters());
int rc = execl(elf_path.characters(), "test-elf", nullptr);
@ -292,10 +284,8 @@ TEST_CASE(test_load_header_p_memsz_not_equal_to_p_align)
int nwritten = write(fd, buffer, sizeof(buffer));
EXPECT(nwritten);
auto elf_path_or_error = FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd));
EXPECT(!elf_path_or_error.is_error());
auto elf_path = elf_path_or_error.release_value().to_deprecated_string();
auto elf_path_string = TRY_OR_FAIL(FileSystem::read_link(DeprecatedString::formatted("/proc/{}/fd/{}", getpid(), fd)));
auto elf_path = elf_path_string.to_deprecated_string();
EXPECT(elf_path.characters());
int rc = execl(elf_path.characters(), "test-elf", nullptr);

23
Tests/LibGfx/TestFontHandling.cpp
View file

@ -146,24 +146,21 @@ TEST_CASE(test_write_to_file)
char path[] = "/tmp/new.font.XXXXXX";
EXPECT(mkstemp(path) != -1);
EXPECT(!font->write_to_file(path).is_error());
TRY_OR_FAIL(font->write_to_file(path));
unlink(path);
}
TEST_CASE(test_character_set_masking)
{
auto font = Gfx::BitmapFont::try_load_from_file(TEST_INPUT("TestFont.font"sv));
EXPECT(!font.is_error());
auto font = TRY_OR_FAIL(Gfx::BitmapFont::try_load_from_file(TEST_INPUT("TestFont.font"sv)));
auto unmasked_font = font.value()->unmasked_character_set();
EXPECT(!unmasked_font.is_error());
EXPECT(unmasked_font.value()->glyph_index(0x0041).value() == 0x0041);
EXPECT(unmasked_font.value()->glyph_index(0x0100).value() == 0x0100);
EXPECT(unmasked_font.value()->glyph_index(0xFFFD).value() == 0xFFFD);
auto unmasked_font = TRY_OR_FAIL(font->unmasked_character_set());
EXPECT(unmasked_font->glyph_index(0x0041).value() == 0x0041);
EXPECT(unmasked_font->glyph_index(0x0100).value() == 0x0100);
EXPECT(unmasked_font->glyph_index(0xFFFD).value() == 0xFFFD);
auto masked_font = unmasked_font.value()->masked_character_set();
EXPECT(!masked_font.is_error());
EXPECT(masked_font.value()->glyph_index(0x0041).value() == 0x0041);
EXPECT(!masked_font.value()->glyph_index(0x0100).has_value());
EXPECT(masked_font.value()->glyph_index(0xFFFD).value() == 0x1FD);
auto masked_font = TRY_OR_FAIL(unmasked_font->masked_character_set());
EXPECT(masked_font->glyph_index(0x0041).value() == 0x0041);
EXPECT(!masked_font->glyph_index(0x0100).has_value());
EXPECT(masked_font->glyph_index(0xFFFD).value() == 0x1FD);
}

56
Tests/LibJS/test-bytecode-js.cpp
View file

@ -12,33 +12,32 @@
#include <LibJS/Script.h>
#include <LibTest/TestCase.h>
#define SETUP_AND_PARSE(source) \
auto vm = MUST(JS::VM::create()); \
auto ast_interpreter = JS::Interpreter::create<JS::GlobalObject>(*vm); \
\
auto script_or_error = JS::Script::parse(source##sv, ast_interpreter->realm()); \
EXPECT(!script_or_error.is_error()); \
\
auto script = script_or_error.release_value(); \
auto const& program = script->parse_node(); \
#define SETUP_AND_PARSE(source) \
auto vm = MUST(JS::VM::create()); \
auto ast_interpreter = JS::Interpreter::create<JS::GlobalObject>(*vm); \
\
auto script = MUST(JS::Script::parse(source##sv, ast_interpreter->realm())); \
auto const& program = script->parse_node(); \
JS::Bytecode::Interpreter bytecode_interpreter(ast_interpreter->realm());
#define EXPECT_NO_EXCEPTION(executable) \
auto executable = MUST(JS::Bytecode::Generator::generate(program)); \
auto result = bytecode_interpreter.run(*executable); \
EXPECT(!result.is_error()); \
if (result.is_error()) \
dbgln("Error: {}", MUST(result.throw_completion().value()->to_deprecated_string(vm)));
#define EXPECT_NO_EXCEPTION(executable) \
auto executable = MUST(JS::Bytecode::Generator::generate(program)); \
auto result = bytecode_interpreter.run(*executable); \
if (result.is_error()) { \
FAIL("unexpected exception"); \
dbgln("Error: {}", MUST(result.throw_completion().value()->to_deprecated_string(vm))); \
}
#define EXPECT_NO_EXCEPTION_WITH_OPTIMIZATIONS(executable) \
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline(); \
passes.perform(*executable); \
\
auto result_with_optimizations = bytecode_interpreter.run(*executable); \
\
EXPECT(!result_with_optimizations.is_error()); \
if (result_with_optimizations.is_error()) \
dbgln("Error: {}", MUST(result_with_optimizations.throw_completion().value()->to_deprecated_string(vm)));
#define EXPECT_NO_EXCEPTION_WITH_OPTIMIZATIONS(executable) \
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline(); \
passes.perform(*executable); \
\
auto result_with_optimizations = bytecode_interpreter.run(*executable); \
\
if (result_with_optimizations.is_error()) { \
FAIL("unexpected exception"); \
dbgln("Error: {}", MUST(result_with_optimizations.throw_completion().value()->to_deprecated_string(vm))); \
}
#define EXPECT_NO_EXCEPTION_ALL(source) \
SETUP_AND_PARSE("(() => {\n" source "\n})()") \
@ -111,15 +110,14 @@ TEST_CASE(loading_multiple_files)
}
{
auto test_file_script_or_error = JS::Script::parse("if (f() !== 'hello') throw new Exception('failed'); "sv, ast_interpreter->realm());
EXPECT(!test_file_script_or_error.is_error());
auto test_file_script = MUST(JS::Script::parse(
"if (f() !== 'hello') throw new Exception('failed'); "sv, ast_interpreter->realm()));
auto test_file_script = test_file_script_or_error.release_value();
auto const& test_file_program = test_file_script->parse_node();
auto executable = MUST(JS::Bytecode::Generator::generate(test_file_program));
auto result = bytecode_interpreter.run(*executable);
EXPECT(!result.is_error());
// TODO: This could be TRY_OR_FAIL(), if someone implements Formatter<JS::Completion>.
MUST(bytecode_interpreter.run(*executable));
}
}

21
Tests/LibPDF/TestPDF.cpp
View file

@ -14,28 +14,25 @@
TEST_CASE(linearized_pdf)
{
auto file = Core::MappedFile::map("linearized.pdf"sv).release_value();
auto document = PDF::Document::create(file->bytes());
EXPECT(!document.is_error());
EXPECT(!document.value()->initialize().is_error());
EXPECT_EQ(document.value()->get_page_count(), 1U);
auto document = MUST(PDF::Document::create(file->bytes()));
MUST(document->initialize());
EXPECT_EQ(document->get_page_count(), 1U);
}
TEST_CASE(non_linearized_pdf)
{
auto file = Core::MappedFile::map("non-linearized.pdf"sv).release_value();
auto document = PDF::Document::create(file->bytes());
EXPECT(!document.is_error());
EXPECT(!document.value()->initialize().is_error());
EXPECT_EQ(document.value()->get_page_count(), 1U);
auto document = MUST(PDF::Document::create(file->bytes()));
MUST(document->initialize());
EXPECT_EQ(document->get_page_count(), 1U);
}
TEST_CASE(complex_pdf)
{
auto file = Core::MappedFile::map("complex.pdf"sv).release_value();
auto document = PDF::Document::create(file->bytes());
EXPECT(!document.is_error());
EXPECT(!document.value()->initialize().is_error());
EXPECT_EQ(document.value()->get_page_count(), 3U);
auto document = MUST(PDF::Document::create(file->bytes()));
MUST(document->initialize());
EXPECT_EQ(document->get_page_count(), 3U);
}
TEST_CASE(empty_file_issue_10702)

8
Tests/LibSQL/TestSqlBtreeIndex.cpp
View file

@ -146,7 +146,7 @@ void insert_and_get_to_and_from_btree(int num_keys)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto btree = setup_btree(serializer);
@ -163,7 +163,7 @@ void insert_and_get_to_and_from_btree(int num_keys)
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto btree = setup_btree(serializer);
@ -182,7 +182,7 @@ void insert_into_and_scan_btree(int num_keys)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto btree = setup_btree(serializer);
@ -200,7 +200,7 @@ void insert_into_and_scan_btree(int num_keys)
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto btree = setup_btree(serializer);

43
Tests/LibSQL/TestSqlDatabase.cpp
View file

@ -25,8 +25,7 @@ void commit(SQL::Database&);
NonnullRefPtr<SQL::SchemaDef> setup_schema(SQL::Database& db)
{
auto schema = SQL::SchemaDef::construct("TestSchema");
auto maybe_error = db.add_schema(schema);
EXPECT(!maybe_error.is_error());
MUST(db.add_schema(schema));
return schema;
}
@ -37,8 +36,7 @@ NonnullRefPtr<SQL::TableDef> setup_table(SQL::Database& db)
table->append_column("TextColumn", SQL::SQLType::Text);
table->append_column("IntColumn", SQL::SQLType::Integer);
EXPECT_EQ(table->num_columns(), 2u);
auto maybe_error = db.add_table(table);
EXPECT(!maybe_error.is_error());
MUST(db.add_table(table));
return table;
}
@ -53,8 +51,7 @@ void insert_into_table(SQL::Database& db, int count)
row["TextColumn"] = builder.to_deprecated_string();
row["IntColumn"] = ix;
auto maybe_error = db.insert(row);
EXPECT(!maybe_error.is_error());
TRY_OR_FAIL(db.insert(row));
}
}
@ -64,9 +61,8 @@ void verify_table_contents(SQL::Database& db, int expected_count)
int sum = 0;
int count = 0;
auto rows_or_error = db.select_all(*table);
EXPECT(!rows_or_error.is_error());
for (auto& row : rows_or_error.value()) {
auto rows = TRY_OR_FAIL(db.select_all(*table));
for (auto& row : rows) {
StringBuilder builder;
builder.appendff("Test{}", row["IntColumn"].to_int<i32>().value());
EXPECT_EQ(row["TextColumn"].to_deprecated_string(), builder.to_deprecated_string());
@ -79,8 +75,7 @@ void verify_table_contents(SQL::Database& db, int expected_count)
void commit(SQL::Database& db)
{
auto maybe_error = db.commit();
EXPECT(!maybe_error.is_error());
TRY_OR_FAIL(db.commit());
}
void insert_and_verify(int count)
@ -88,19 +83,19 @@ void insert_and_verify(int count)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
(void)setup_table(db);
commit(db);
}
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
insert_into_table(db, count);
commit(db);
}
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
verify_table_contents(db, count);
}
}
@ -109,7 +104,7 @@ TEST_CASE(create_heap)
{
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
EXPECT_EQ(heap->version(), SQL::Heap::VERSION);
}
@ -138,8 +133,7 @@ TEST_CASE(create_database)
{
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
auto db = SQL::Database::construct("/tmp/test.db");
auto should_not_be_error = db->open();
EXPECT(!should_not_be_error.is_error());
MUST(db->open());
commit(db);
}
@ -147,7 +141,7 @@ TEST_CASE(add_schema_to_database)
{
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
(void)setup_schema(db);
commit(db);
}
@ -157,15 +151,14 @@ TEST_CASE(get_schema_from_database)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
(void)setup_schema(db);
commit(db);
}
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
auto schema_or_error = db->get_schema("TestSchema");
EXPECT(!schema_or_error.is_error());
MUST(db->open());
auto schema = MUST(db->get_schema("TestSchema"));
}
}
@ -173,7 +166,7 @@ TEST_CASE(add_table_to_database)
{
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
(void)setup_table(db);
commit(db);
}
@ -183,13 +176,13 @@ TEST_CASE(get_table_from_database)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
(void)setup_table(db);
commit(db);
}
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
auto table = MUST(db->get_table("TestSchema", "TestTable"));
EXPECT_EQ(table->name(), "TestTable");

107
Tests/LibSQL/TestSqlExpressionParser.cpp
View file

@ -58,10 +58,7 @@ TEST_CASE(numeric_literal)
// EXPECT(parse("0x"sv).is_error());
auto validate = [](StringView sql, double expected_value) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::NumericLiteral>(*expression));
const auto& literal = static_cast<const SQL::AST::NumericLiteral&>(*expression);
@ -82,10 +79,7 @@ TEST_CASE(string_literal)
EXPECT(parse("'unterminated"sv).is_error());
auto validate = [](StringView sql, StringView expected_value) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::StringLiteral>(*expression));
const auto& literal = static_cast<const SQL::AST::StringLiteral&>(*expression);
@ -104,10 +98,7 @@ TEST_CASE(blob_literal)
EXPECT(parse("x'NOTHEX'"sv).is_error());
auto validate = [](StringView sql, StringView expected_value) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::BlobLiteral>(*expression));
const auto& literal = static_cast<const SQL::AST::BlobLiteral&>(*expression);
@ -121,10 +112,7 @@ TEST_CASE(blob_literal)
TEST_CASE(boolean_literal)
{
auto validate = [](StringView sql, bool expected_value) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::BooleanLiteral>(*expression));
auto const& literal = static_cast<SQL::AST::BooleanLiteral const&>(*expression);
@ -138,10 +126,7 @@ TEST_CASE(boolean_literal)
TEST_CASE(null_literal)
{
auto validate = [](StringView sql) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::NullLiteral>(*expression));
};
@ -151,10 +136,7 @@ TEST_CASE(null_literal)
TEST_CASE(bind_parameter)
{
auto validate = [](StringView sql) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Placeholder>(*expression));
};
@ -169,10 +151,7 @@ TEST_CASE(column_name)
EXPECT(parse("\"unterminated"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::ColumnNameExpression>(*expression));
const auto& column = static_cast<const SQL::AST::ColumnNameExpression&>(*expression);
@ -199,10 +178,7 @@ TEST_CASE(unary_operator)
EXPECT(parse("NOT"sv).is_error());
auto validate = [](StringView sql, SQL::AST::UnaryOperator expected_operator) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::UnaryOperatorExpression>(*expression));
const auto& unary = static_cast<const SQL::AST::UnaryOperatorExpression&>(*expression);
@ -261,10 +237,7 @@ TEST_CASE(binary_operator)
}
auto validate = [](StringView sql, SQL::AST::BinaryOperator expected_operator) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::BinaryOperatorExpression>(*expression));
const auto& binary = static_cast<const SQL::AST::BinaryOperatorExpression&>(*expression);
@ -289,10 +262,7 @@ TEST_CASE(chained_expression)
EXPECT(parse("(15,)"sv).is_error());
auto validate = [](StringView sql, size_t expected_chain_size) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::ChainedExpression>(*expression));
const auto& chain = static_cast<const SQL::AST::ChainedExpression&>(*expression).expressions();
@ -318,12 +288,7 @@ TEST_CASE(cast_expression)
EXPECT(parse("CAST (15 AS int"sv).is_error());
auto validate = [](StringView sql, StringView expected_type_name) {
auto result = parse(sql);
if (result.is_error())
outln("{}: {}", sql, result.error());
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::CastExpression>(*expression));
const auto& cast = static_cast<const SQL::AST::CastExpression&>(*expression);
@ -354,10 +319,7 @@ TEST_CASE(case_expression)
EXPECT(parse("CASE WHEN 15 THEN 16 ELSE END"sv).is_error());
auto validate = [](StringView sql, bool expect_case_expression, size_t expected_when_then_size, bool expect_else_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::CaseExpression>(*expression));
const auto& case_ = static_cast<const SQL::AST::CaseExpression&>(*expression);
@ -407,10 +369,7 @@ TEST_CASE(exists_expression)
EXPECT(parse("(SELECT * FROM table_name"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::ExistsExpression>(*expression));
const auto& exists = static_cast<const SQL::AST::ExistsExpression&>(*expression);
@ -429,10 +388,7 @@ TEST_CASE(collate_expression)
EXPECT(parse("15 COLLATE"sv).is_error());
auto validate = [](StringView sql, StringView expected_collation_name) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::CollateExpression>(*expression));
const auto& collate = static_cast<const SQL::AST::CollateExpression&>(*expression);
@ -454,10 +410,7 @@ TEST_CASE(is_expression)
EXPECT(parse("1 IS NOT"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::IsExpression>(*expression));
const auto& is_ = static_cast<const SQL::AST::IsExpression&>(*expression);
@ -494,10 +447,7 @@ TEST_CASE(match_expression)
}
auto validate = [](StringView sql, SQL::AST::MatchOperator expected_operator, bool expected_invert_expression, bool expect_escape) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::MatchExpression>(*expression));
const auto& match = static_cast<const SQL::AST::MatchExpression&>(*expression);
@ -536,10 +486,7 @@ TEST_CASE(null_expression)
EXPECT(parse("15 NOT"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::NullExpression>(*expression));
const auto& null = static_cast<const SQL::AST::NullExpression&>(*expression);
@ -563,10 +510,7 @@ TEST_CASE(between_expression)
EXPECT(parse("15 BETWEEN 10 OR 20"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::BetweenExpression>(*expression));
const auto& between = static_cast<const SQL::AST::BetweenExpression&>(*expression);
@ -588,10 +532,7 @@ TEST_CASE(in_table_expression)
EXPECT(parse("NOT IN table_name"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::InTableExpression>(*expression));
const auto& in = static_cast<const SQL::AST::InTableExpression&>(*expression);
@ -614,10 +555,7 @@ TEST_CASE(in_chained_expression)
EXPECT(parse("NOT IN ()"sv).is_error());
auto validate = [](StringView sql, size_t expected_chain_size, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::InChainedExpression>(*expression));
const auto& in = static_cast<const SQL::AST::InChainedExpression&>(*expression);
@ -646,10 +584,7 @@ TEST_CASE(in_selection_expression)
EXPECT(parse("NOT IN (SELECT * FROM table_name, SELECT * FROM table_name);"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::InSelectionExpression>(*expression));
const auto& in = static_cast<const SQL::AST::InSelectionExpression&>(*expression);

8
Tests/LibSQL/TestSqlHashIndex.cpp
View file

@ -141,7 +141,7 @@ void insert_and_get_to_and_from_hash_index(int num_keys)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto hash_index = setup_hash_index(serializer);
@ -159,7 +159,7 @@ void insert_and_get_to_and_from_hash_index(int num_keys)
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto hash_index = setup_hash_index(serializer);
@ -239,7 +239,7 @@ void insert_into_and_scan_hash_index(int num_keys)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto hash_index = setup_hash_index(serializer);
@ -257,7 +257,7 @@ void insert_into_and_scan_hash_index(int num_keys)
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto hash_index = setup_hash_index(serializer);
Vector<bool> found;

114
Tests/LibSQL/TestSqlStatementExecution.cpp
View file

@ -73,27 +73,25 @@ TEST_CASE(create_schema)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_schema(database);
auto schema_or_error = database->get_schema("TESTSCHEMA");
EXPECT(!schema_or_error.is_error());
auto schema = MUST(database->get_schema("TESTSCHEMA"));
}
TEST_CASE(create_table)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto table_or_error = database->get_table("TESTSCHEMA", "TESTTABLE");
EXPECT(!table_or_error.is_error());
auto table = MUST(database->get_table("TESTSCHEMA", "TESTTABLE"));
}
TEST_CASE(insert_into_table)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test', 42 );");
EXPECT(result.size() == 1);
@ -101,9 +99,8 @@ TEST_CASE(insert_into_table)
auto table = MUST(database->get_table("TESTSCHEMA", "TESTTABLE"));
int count = 0;
auto rows_or_error = database->select_all(*table);
EXPECT(!rows_or_error.is_error());
for (auto& row : rows_or_error.value()) {
auto rows = TRY_OR_FAIL(database->select_all(*table));
for (auto& row : rows) {
EXPECT_EQ(row["TEXTCOLUMN"].to_deprecated_string(), "Test");
EXPECT_EQ(row["INTCOLUMN"].to_int<i32>(), 42);
count++;
@ -115,7 +112,7 @@ TEST_CASE(insert_into_table_wrong_data_types)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = try_execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES (43, 'Test_2');");
EXPECT(result.is_error());
@ -126,7 +123,7 @@ TEST_CASE(insert_into_table_multiple_tuples_wrong_data_types)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = try_execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ('Test_1', 42), (43, 'Test_2');");
EXPECT(result.is_error());
@ -137,7 +134,7 @@ TEST_CASE(insert_wrong_number_of_values)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = try_execute(database, "INSERT INTO TestSchema.TestTable VALUES ( 42 );");
EXPECT(result.is_error());
@ -148,7 +145,7 @@ TEST_CASE(insert_identifier_as_value)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = try_execute(database, "INSERT INTO TestSchema.TestTable VALUES ( identifier, 42 );");
EXPECT(result.is_error());
@ -159,7 +156,7 @@ TEST_CASE(insert_quoted_identifier_as_value)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = try_execute(database, "INSERT INTO TestSchema.TestTable VALUES ( \"QuotedIdentifier\", 42 );");
EXPECT(result.is_error());
@ -170,15 +167,14 @@ TEST_CASE(insert_without_column_names)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ('Test_1', 42), ('Test_2', 43);");
EXPECT(result.size() == 2);
auto table = MUST(database->get_table("TESTSCHEMA", "TESTTABLE"));
auto rows_or_error = database->select_all(*table);
EXPECT(!rows_or_error.is_error());
EXPECT_EQ(rows_or_error.value().size(), 2u);
auto rows = TRY_OR_FAIL(database->select_all(*table));
EXPECT_EQ(rows.size(), 2u);
}
TEST_CASE(insert_with_placeholders)
@ -186,7 +182,7 @@ TEST_CASE(insert_with_placeholders)
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
{
@ -238,7 +234,7 @@ TEST_CASE(insert_and_retrieve_long_text_value)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
StringBuilder sb;
@ -256,7 +252,7 @@ TEST_CASE(select_from_empty_table)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database, "SELECT * FROM TestSchema.TestTable;");
EXPECT(result.is_empty());
@ -266,7 +262,7 @@ TEST_CASE(select_from_table)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -284,7 +280,7 @@ TEST_CASE(select_with_column_names)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -303,7 +299,7 @@ TEST_CASE(select_with_nonexisting_column_name)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -323,7 +319,7 @@ TEST_CASE(select_with_where)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -344,7 +340,7 @@ TEST_CASE(select_cross_join)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_two_tables(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable1 ( TextColumn1, IntColumn ) VALUES "
@ -377,7 +373,7 @@ TEST_CASE(select_inner_join)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_two_tables(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable1 ( TextColumn1, IntColumn ) VALUES "
@ -410,7 +406,7 @@ TEST_CASE(select_with_like)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -468,7 +464,7 @@ TEST_CASE(select_with_order)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -500,7 +496,7 @@ TEST_CASE(select_with_regexp)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -535,7 +531,7 @@ TEST_CASE(handle_regexp_errors)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -551,7 +547,7 @@ TEST_CASE(select_with_order_two_columns)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -580,7 +576,7 @@ TEST_CASE(select_with_order_by_column_not_in_result)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -604,7 +600,7 @@ TEST_CASE(select_with_limit)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 100; count++) {
auto result = execute(database,
@ -620,7 +616,7 @@ TEST_CASE(select_with_limit_and_offset)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 100; count++) {
auto result = execute(database,
@ -635,7 +631,7 @@ TEST_CASE(select_with_order_limit_and_offset)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 100; count++) {
auto result = execute(database,
@ -660,7 +656,7 @@ TEST_CASE(select_with_limit_out_of_bounds)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 100; count++) {
auto result = execute(database,
@ -675,7 +671,7 @@ TEST_CASE(select_with_offset_out_of_bounds)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 100; count++) {
auto result = execute(database,
@ -690,7 +686,7 @@ TEST_CASE(describe_table)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database, "DESCRIBE TABLE TestSchema.TestTable;");
EXPECT_EQ(result.size(), 2u);
@ -706,7 +702,7 @@ TEST_CASE(binary_operator_execution)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -780,7 +776,7 @@ TEST_CASE(binary_operator_failure)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -831,14 +827,14 @@ TEST_CASE(describe_large_table_after_persist)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "CREATE TABLE Cookies ( name TEXT, value TEXT, same_site INTEGER, creation_time INTEGER, last_access_time INTEGER, expiry_time INTEGER, domain TEXT, path TEXT, secure INTEGER, http_only INTEGER, host_only INTEGER, persistent INTEGER );");
EXPECT_EQ(result.command(), SQL::SQLCommand::Create);
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "DESCRIBE TABLE Cookies;");
EXPECT_EQ(result.size(), 12u);
@ -850,7 +846,7 @@ TEST_CASE(delete_single_row)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -863,7 +859,7 @@ TEST_CASE(delete_single_row)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
execute(database, "DELETE FROM TestSchema.TestTable WHERE (IntColumn = 4);");
@ -877,7 +873,7 @@ TEST_CASE(delete_single_row)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT_EQ(result.size(), 9u);
@ -894,7 +890,7 @@ TEST_CASE(delete_multiple_rows)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -907,7 +903,7 @@ TEST_CASE(delete_multiple_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
execute(database, "DELETE FROM TestSchema.TestTable WHERE (IntColumn >= 4);");
@ -919,7 +915,7 @@ TEST_CASE(delete_multiple_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT_EQ(result.size(), 4u);
@ -934,7 +930,7 @@ TEST_CASE(delete_all_rows)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -947,7 +943,7 @@ TEST_CASE(delete_all_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
execute(database, "DELETE FROM TestSchema.TestTable;");
@ -956,7 +952,7 @@ TEST_CASE(delete_all_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT * FROM TestSchema.TestTable;");
EXPECT(result.is_empty());
@ -968,7 +964,7 @@ TEST_CASE(update_single_row)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -992,7 +988,7 @@ TEST_CASE(update_single_row)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT_EQ(result.size(), 10u);
@ -1013,7 +1009,7 @@ TEST_CASE(update_multiple_rows)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -1035,7 +1031,7 @@ TEST_CASE(update_multiple_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT_EQ(result.size(), 10u);
@ -1054,7 +1050,7 @@ TEST_CASE(update_all_rows)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -1072,7 +1068,7 @@ TEST_CASE(update_all_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT_EQ(result.size(), 10u);

64
Tests/LibSQL/TestSqlStatementParser.cpp
View file

@ -66,12 +66,7 @@ TEST_CASE(create_table)
};
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, Vector<Column> expected_columns, bool expected_is_temporary = false, bool expected_is_error_if_table_exists = true) {
auto result = parse(sql);
if (result.is_error())
outln("{}: {}", sql, result.error());
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::CreateTable>(*statement));
const auto& table = static_cast<const SQL::AST::CreateTable&>(*statement);
@ -147,10 +142,7 @@ TEST_CASE(alter_table_rename_table)
EXPECT(parse("ALTER TABLE table_name RENAME TO new_table"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_new_table) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::RenameTable>(*statement));
const auto& alter = static_cast<const SQL::AST::RenameTable&>(*statement);
@ -175,10 +167,7 @@ TEST_CASE(alter_table_rename_column)
EXPECT(parse("ALTER TABLE table_name RENAME column_name TO new_column"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column, StringView expected_new_column) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::RenameColumn>(*statement));
const auto& alter = static_cast<const SQL::AST::RenameColumn&>(*statement);
@ -207,10 +196,7 @@ TEST_CASE(alter_table_add_column)
};
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, Column expected_column) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::AddColumn>(*statement));
const auto& alter = static_cast<const SQL::AST::AddColumn&>(*statement);
@ -254,10 +240,7 @@ TEST_CASE(alter_table_drop_column)
EXPECT(parse("ALTER TABLE table_name DROP COLUMN column_name"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::DropColumn>(*statement));
const auto& alter = static_cast<const SQL::AST::DropColumn&>(*statement);
@ -280,10 +263,7 @@ TEST_CASE(drop_table)
EXPECT(parse("DROP TABLE IF test;"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, bool expected_is_error_if_table_does_not_exist = true) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::DropTable>(*statement));
const auto& table = static_cast<const SQL::AST::DropTable&>(*statement);
@ -321,10 +301,7 @@ TEST_CASE(insert)
EXPECT(parse("INSERT OR foo INTO table_name DEFAULT VALUES;"sv).is_error());
auto validate = [](StringView sql, SQL::AST::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<StringView> expected_column_names, Vector<size_t> expected_chain_sizes, bool expect_select_statement) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Insert>(*statement));
const auto& insert = static_cast<const SQL::AST::Insert&>(*statement);
@ -417,10 +394,7 @@ TEST_CASE(update)
EXPECT(parse("UPDATE OR foo table_name SET column_name=4;"sv).is_error());
auto validate = [](StringView sql, SQL::AST::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<Vector<DeprecatedString>> expected_update_columns, bool expect_where_clause, bool expect_returning_clause, Vector<StringView> expected_returned_column_aliases) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Update>(*statement));
const auto& update = static_cast<const SQL::AST::Update&>(*statement);
@ -514,10 +488,7 @@ TEST_CASE(delete_)
EXPECT(parse("DELETE FROM table_name WHERE (');"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_alias, bool expect_where_clause, bool expect_returning_clause, Vector<StringView> expected_returned_column_aliases) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Delete>(*statement));
const auto& delete_ = static_cast<const SQL::AST::Delete&>(*statement);
@ -613,10 +584,7 @@ TEST_CASE(select)
};
auto validate = [](StringView sql, Vector<Type> expected_columns, Vector<From> expected_from_list, bool expect_where_clause, size_t expected_group_by_size, bool expect_having_clause, Vector<Ordering> expected_ordering, bool expect_limit_clause, bool expect_offset_clause) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Select>(*statement));
const auto& select = static_cast<const SQL::AST::Select&>(*statement);
@ -752,10 +720,7 @@ TEST_CASE(common_table_expression)
};
auto validate = [](StringView sql, SelectedTableList expected_selected_tables) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Delete>(*statement));
const auto& delete_ = static_cast<const SQL::AST::Delete&>(*statement);
@ -807,12 +772,7 @@ TEST_CASE(describe_table)
EXPECT(parse("DESCRIBE table_name;"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table) {
auto result = parse(sql);
if (result.is_error())
outln("{}: {}", sql, result.error());
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::DescribeTable>(*statement));
const auto& describe_table_statement = static_cast<const SQL::AST::DescribeTable&>(*statement);

32
Tests/LibSQL/TestSqlValueAndTuple.cpp
View file

@ -688,7 +688,6 @@ TEST_CASE(add)
SQL::Value value2 { 42 };
auto result = value1.add(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 63);
}
@ -697,7 +696,6 @@ TEST_CASE(add)
SQL::Value value2 { static_cast<u8>(42) };
auto result = value1.add(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 63);
}
@ -706,7 +704,6 @@ TEST_CASE(add)
SQL::Value value2 { 42 };
auto result = value1.add(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 63);
}
@ -715,7 +712,6 @@ TEST_CASE(add)
SQL::Value value2 { 42 };
auto result = value1.add(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 63);
}
@ -724,7 +720,6 @@ TEST_CASE(add)
SQL::Value value2 { 42 };
auto result = value1.add(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
EXPECT((result.value().to_double().value() - 63.5) < NumericLimits<double>().epsilon());
}
@ -777,7 +772,6 @@ TEST_CASE(subtract)
SQL::Value value2 { 42 };
auto result = value1.subtract(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), -21);
}
@ -786,7 +780,6 @@ TEST_CASE(subtract)
SQL::Value value2 { static_cast<u8>(42) };
auto result = value1.subtract(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), -21);
}
@ -795,7 +788,6 @@ TEST_CASE(subtract)
SQL::Value value2 { 21 };
auto result = value1.subtract(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 21);
}
@ -804,7 +796,6 @@ TEST_CASE(subtract)
SQL::Value value2 { 42 };
auto result = value1.subtract(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), -21);
}
@ -813,7 +804,6 @@ TEST_CASE(subtract)
SQL::Value value2 { 42 };
auto result = value1.subtract(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
EXPECT((result.value().to_double().value() - 20.5) < NumericLimits<double>().epsilon());
}
@ -866,7 +856,6 @@ TEST_CASE(multiply)
SQL::Value value2 { 21 };
auto result = value1.multiply(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 42);
}
@ -875,7 +864,6 @@ TEST_CASE(multiply)
SQL::Value value2 { static_cast<u8>(21) };
auto result = value1.multiply(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 42);
}
@ -884,7 +872,6 @@ TEST_CASE(multiply)
SQL::Value value2 { 21 };
auto result = value1.multiply(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 42);
}
@ -893,7 +880,6 @@ TEST_CASE(multiply)
SQL::Value value2 { 21 };
auto result = value1.multiply(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 42);
}
@ -902,7 +888,6 @@ TEST_CASE(multiply)
SQL::Value value2 { 21 };
auto result = value1.multiply(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
EXPECT((result.value().to_double().value() - 52.5) < NumericLimits<double>().epsilon());
}
@ -955,7 +940,6 @@ TEST_CASE(divide)
SQL::Value value2 { -2 };
auto result = value1.divide(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), -21);
}
@ -964,7 +948,6 @@ TEST_CASE(divide)
SQL::Value value2 { static_cast<u8>(2) };
auto result = value1.divide(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 21);
}
@ -973,7 +956,6 @@ TEST_CASE(divide)
SQL::Value value2 { 2 };
auto result = value1.divide(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 21);
}
@ -982,7 +964,6 @@ TEST_CASE(divide)
SQL::Value value2 { 2 };
auto result = value1.divide(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 21);
}
@ -991,7 +972,6 @@ TEST_CASE(divide)
SQL::Value value2 { 2 };
auto result = value1.divide(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
EXPECT((result.value().to_double().value() - 21.5) < NumericLimits<double>().epsilon());
}
@ -1026,7 +1006,6 @@ TEST_CASE(modulo)
SQL::Value value2 { 2 };
auto result = value1.modulo(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 1);
}
@ -1035,7 +1014,6 @@ TEST_CASE(modulo)
SQL::Value value2 { static_cast<u8>(2) };
auto result = value1.modulo(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 1);
}
@ -1044,7 +1022,6 @@ TEST_CASE(modulo)
SQL::Value value2 { 2 };
auto result = value1.modulo(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 1);
}
@ -1053,7 +1030,6 @@ TEST_CASE(modulo)
SQL::Value value2 { 2 };
auto result = value1.modulo(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 1);
}
@ -1115,7 +1091,6 @@ TEST_CASE(shift_left)
SQL::Value value2 { 2 };
auto result = value1.shift_left(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b1100'0000);
}
@ -1124,7 +1099,6 @@ TEST_CASE(shift_left)
SQL::Value value2 { static_cast<u8>(2) };
auto result = value1.shift_left(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b1100'0000);
}
@ -1133,7 +1107,6 @@ TEST_CASE(shift_left)
SQL::Value value2 { 2 };
auto result = value1.shift_left(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b1100'0000);
}
@ -1142,7 +1115,6 @@ TEST_CASE(shift_left)
SQL::Value value2 { 2 };
auto result = value1.shift_left(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b1100'0000);
}
@ -1213,7 +1185,6 @@ TEST_CASE(shift_right)
SQL::Value value2 { 2 };
auto result = value1.shift_right(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b0000'1100);
}
@ -1222,7 +1193,6 @@ TEST_CASE(shift_right)
SQL::Value value2 { static_cast<u8>(2) };
auto result = value1.shift_right(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b0000'1100);
}
@ -1231,7 +1201,6 @@ TEST_CASE(shift_right)
SQL::Value value2 { 2 };
auto result = value1.shift_right(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b0000'1100);
}
@ -1240,7 +1209,6 @@ TEST_CASE(shift_right)
SQL::Value value2 { 2 };
auto result = value1.shift_right(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b0000'1100);
}

6
Tests/LibThreading/TestThread.cpp
View file

@ -50,8 +50,6 @@ TEST_CASE(join_dead_thread)
// The thread should have exited by then.
usleep(40 * 1000);
auto join_result = thread->join<int*>();
EXPECT(!join_result.is_error());
EXPECT_EQ(join_result.value(), static_cast<int*>(0));
auto join_result = TRY_OR_FAIL(thread->join<int*>());
EXPECT_EQ(join_result, static_cast<int*>(0));
}