diff --git a/Tests/AK/TestBase64.cpp b/Tests/AK/TestBase64.cpp index f6f79b17378..f4b3d114972 100644 --- a/Tests/AK/TestBase64.cpp +++ b/Tests/AK/TestBase64.cpp @@ -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())); }; diff --git a/Tests/AK/TestCircularBuffer.cpp b/Tests/AK/TestCircularBuffer.cpp index 309bfbf2979..3b6b56caf7d 100644 --- a/Tests/AK/TestCircularBuffer.cpp +++ b/Tests/AK/TestCircularBuffer.cpp @@ -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); diff --git a/Tests/Kernel/TestKernelFilePermissions.cpp b/Tests/Kernel/TestKernelFilePermissions.cpp index 1dbab644bd3..12b7831d0a1 100644 --- a/Tests/Kernel/TestKernelFilePermissions.cpp +++ b/Tests/Kernel/TestKernelFilePermissions.cpp @@ -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); diff --git a/Tests/LibC/TestIo.cpp b/Tests/LibC/TestIo.cpp index c111b2ab4d1..dcd35341bcf 100644 --- a/Tests/LibC/TestIo.cpp +++ b/Tests/LibC/TestIo.cpp @@ -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"); diff --git a/Tests/LibC/TestLibCMkTemp.cpp b/Tests/LibC/TestLibCMkTemp.cpp index 81e4c61309c..658f55ad04b 100644 --- a/Tests/LibC/TestLibCMkTemp.cpp +++ b/Tests/LibC/TestLibCMkTemp.cpp @@ -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); diff --git a/Tests/LibCompress/TestDeflate.cpp b/Tests/LibCompress/TestDeflate.cpp index c4bd0451828..f081fb1cb8b 100644 --- a/Tests/LibCompress/TestDeflate.cpp +++ b/Tests/LibCompress/TestDeflate.cpp @@ -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 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)); } diff --git a/Tests/LibCompress/TestGzip.cpp b/Tests/LibCompress/TestGzip.cpp index be90cd88e83..294679d42c5 100644 --- a/Tests/LibCompress/TestGzip.cpp +++ b/Tests/LibCompress/TestGzip.cpp @@ -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) diff --git a/Tests/LibCore/TestLibCoreFilePermissionsMask.cpp b/Tests/LibCore/TestLibCoreFilePermissionsMask.cpp index 55f300be5f2..742ca5ae850 100644 --- a/Tests/LibCore/TestLibCoreFilePermissionsMask.cpp +++ b/Tests/LibCore/TestLibCoreFilePermissionsMask.cpp @@ -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); } } diff --git a/Tests/LibCore/TestLibCoreSharedSingleProducerCircularQueue.cpp b/Tests/LibCore/TestLibCoreSharedSingleProducerCircularQueue.cpp index 57c7fa5e4f1..b30be886c90 100644 --- a/Tests/LibCore/TestLibCoreSharedSingleProducerCircularQueue.cpp +++ b/Tests/LibCore/TestLibCoreSharedSingleProducerCircularQueue.cpp @@ -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. + auto const element = MUST(queue.dequeue()); + EXPECT_EQ(element, i); } } diff --git a/Tests/LibCore/TestLibCoreStream.cpp b/Tests/LibCore/TestLibCoreStream.cpp index 3ee97091a12..fff9054823f 100644 --- a/Tests/LibCore/TestLibCoreStream.cpp +++ b/Tests/LibCore/TestLibCoreStream.cpp @@ -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 = "<small>(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 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::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 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); } diff --git a/Tests/LibEDID/TestEDID.cpp b/Tests/LibEDID/TestEDID.cpp index ffe36e17ad1..c944201f6ea 100644 --- a/Tests/LibEDID/TestEDID.cpp +++ b/Tests/LibEDID/TestEDID.cpp @@ -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); } } diff --git a/Tests/LibELF/test-elf.cpp b/Tests/LibELF/test-elf.cpp index 2dc2590557b..70c0b106c07 100644 --- a/Tests/LibELF/test-elf.cpp +++ b/Tests/LibELF/test-elf.cpp @@ -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); diff --git a/Tests/LibGfx/TestFontHandling.cpp b/Tests/LibGfx/TestFontHandling.cpp index a1cde06f267..1c229895941 100644 --- a/Tests/LibGfx/TestFontHandling.cpp +++ b/Tests/LibGfx/TestFontHandling.cpp @@ -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); } diff --git a/Tests/LibJS/test-bytecode-js.cpp b/Tests/LibJS/test-bytecode-js.cpp index 57eade2d0d2..ed2641a1edf 100644 --- a/Tests/LibJS/test-bytecode-js.cpp +++ b/Tests/LibJS/test-bytecode-js.cpp @@ -12,33 +12,32 @@ #include #include -#define SETUP_AND_PARSE(source) \ - auto vm = MUST(JS::VM::create()); \ - auto ast_interpreter = JS::Interpreter::create(*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(*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. + MUST(bytecode_interpreter.run(*executable)); } } diff --git a/Tests/LibPDF/TestPDF.cpp b/Tests/LibPDF/TestPDF.cpp index 01ff0dac602..8b4325c0108 100644 --- a/Tests/LibPDF/TestPDF.cpp +++ b/Tests/LibPDF/TestPDF.cpp @@ -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) diff --git a/Tests/LibSQL/TestSqlBtreeIndex.cpp b/Tests/LibSQL/TestSqlBtreeIndex.cpp index 8c74373c3d2..9a2c8859808 100644 --- a/Tests/LibSQL/TestSqlBtreeIndex.cpp +++ b/Tests/LibSQL/TestSqlBtreeIndex.cpp @@ -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); diff --git a/Tests/LibSQL/TestSqlDatabase.cpp b/Tests/LibSQL/TestSqlDatabase.cpp index 90008f80733..1128f8f6f84 100644 --- a/Tests/LibSQL/TestSqlDatabase.cpp +++ b/Tests/LibSQL/TestSqlDatabase.cpp @@ -25,8 +25,7 @@ void commit(SQL::Database&); NonnullRefPtr 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 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().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"); diff --git a/Tests/LibSQL/TestSqlExpressionParser.cpp b/Tests/LibSQL/TestSqlExpressionParser.cpp index 626cd47250f..1dce2341840 100644 --- a/Tests/LibSQL/TestSqlExpressionParser.cpp +++ b/Tests/LibSQL/TestSqlExpressionParser.cpp @@ -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(*expression)); const auto& literal = static_cast(*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(*expression)); const auto& literal = static_cast(*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(*expression)); const auto& literal = static_cast(*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(*expression)); auto const& literal = static_cast(*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(*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(*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(*expression)); const auto& column = static_cast(*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(*expression)); const auto& unary = static_cast(*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(*expression)); const auto& binary = static_cast(*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(*expression)); const auto& chain = static_cast(*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(*expression)); const auto& cast = static_cast(*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(*expression)); const auto& case_ = static_cast(*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(*expression)); const auto& exists = static_cast(*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(*expression)); const auto& collate = static_cast(*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(*expression)); const auto& is_ = static_cast(*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(*expression)); const auto& match = static_cast(*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(*expression)); const auto& null = static_cast(*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(*expression)); const auto& between = static_cast(*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(*expression)); const auto& in = static_cast(*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(*expression)); const auto& in = static_cast(*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(*expression)); const auto& in = static_cast(*expression); diff --git a/Tests/LibSQL/TestSqlHashIndex.cpp b/Tests/LibSQL/TestSqlHashIndex.cpp index 6e7d2f5a640..4d209638274 100644 --- a/Tests/LibSQL/TestSqlHashIndex.cpp +++ b/Tests/LibSQL/TestSqlHashIndex.cpp @@ -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 found; diff --git a/Tests/LibSQL/TestSqlStatementExecution.cpp b/Tests/LibSQL/TestSqlStatementExecution.cpp index b1691856f87..b3366416fbe 100644 --- a/Tests/LibSQL/TestSqlStatementExecution.cpp +++ b/Tests/LibSQL/TestSqlStatementExecution.cpp @@ -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(), 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); diff --git a/Tests/LibSQL/TestSqlStatementParser.cpp b/Tests/LibSQL/TestSqlStatementParser.cpp index 0793276fe3d..81de1868cfb 100644 --- a/Tests/LibSQL/TestSqlStatementParser.cpp +++ b/Tests/LibSQL/TestSqlStatementParser.cpp @@ -66,12 +66,7 @@ TEST_CASE(create_table) }; auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, Vector 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(*statement)); const auto& table = static_cast(*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(*statement)); const auto& alter = static_cast(*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(*statement)); const auto& alter = static_cast(*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(*statement)); const auto& alter = static_cast(*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(*statement)); const auto& alter = static_cast(*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(*statement)); const auto& table = static_cast(*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 expected_column_names, Vector 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(*statement)); const auto& insert = static_cast(*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> expected_update_columns, bool expect_where_clause, bool expect_returning_clause, Vector 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(*statement)); const auto& update = static_cast(*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 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(*statement)); const auto& delete_ = static_cast(*statement); @@ -613,10 +584,7 @@ TEST_CASE(select) }; auto validate = [](StringView sql, Vector expected_columns, Vector expected_from_list, bool expect_where_clause, size_t expected_group_by_size, bool expect_having_clause, Vector 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(*statement)); const auto& select = static_cast(*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(*statement)); const auto& delete_ = static_cast(*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(*statement)); const auto& describe_table_statement = static_cast(*statement); diff --git a/Tests/LibSQL/TestSqlValueAndTuple.cpp b/Tests/LibSQL/TestSqlValueAndTuple.cpp index fd95a6b67b1..cacdfe61cb3 100644 --- a/Tests/LibSQL/TestSqlValueAndTuple.cpp +++ b/Tests/LibSQL/TestSqlValueAndTuple.cpp @@ -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(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().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(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().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(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().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(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().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(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(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(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); } diff --git a/Tests/LibThreading/TestThread.cpp b/Tests/LibThreading/TestThread.cpp index 72a73d82d5d..1ffee96dc8e 100644 --- a/Tests/LibThreading/TestThread.cpp +++ b/Tests/LibThreading/TestThread.cpp @@ -50,8 +50,6 @@ TEST_CASE(join_dead_thread) // The thread should have exited by then. usleep(40 * 1000); - auto join_result = thread->join(); - - EXPECT(!join_result.is_error()); - EXPECT_EQ(join_result.value(), static_cast(0)); + auto join_result = TRY_OR_FAIL(thread->join()); + EXPECT_EQ(join_result, static_cast(0)); }