beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 15:40:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Tests/LibGfx/TestImageDecoder.cpp

293 lines
10 KiB
C++
Raw Normal View History

Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
/*
* Copyright (c) 2021, the SerenityOS developers.
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
* Copyright (c) 2021, Brian Gianforcaro <bgianf@serenityos.org>
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
*/
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
#include <AK/DeprecatedString.h>
LibCore+AK: Move MappedFile from AK to LibCore MappedFile is strictly a userspace thing, so it doesn't belong in AK (which is supposed to be user/kernel agnostic.)
2021-11-23 10:32:25 +00:00
#include <LibCore/MappedFile.h>
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
#include <LibGfx/BMPLoader.h>
#include <LibGfx/GIFLoader.h>
#include <LibGfx/ICOLoader.h>
#include <LibGfx/ImageDecoder.h>
LibGfx: Rename `JPGLoader` to `JPEGLoader` The patch also contains modifications on several classes, functions or files that are related to the `JPGLoader`. Renaming include: - JPGLoader{.h, .cpp} - JPGImageDecoderPlugin - JPGLoadingContext - JPG_DEBUG - decode_jpg - FuzzJPGLoader.cpp - Few string literals or texts
2023-02-18 21:09:16 +00:00
#include <LibGfx/JPEGLoader.h>
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
#include <LibGfx/PBMLoader.h>
#include <LibGfx/PGMLoader.h>
#include <LibGfx/PNGLoader.h>
#include <LibGfx/PPMLoader.h>
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
#include <LibGfx/TGALoader.h>
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
#include <LibGfx/WebPLoader.h>
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
#include <LibTest/TestCase.h>
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
#include <stdio.h>
#include <string.h>
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
#ifdef AK_OS_SERENITY
# define TEST_INPUT(x) ("/usr/Tests/LibGfx/test-inputs/" x)
#else
# define TEST_INPUT(x) ("test-inputs/" x)
#endif
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_bmp)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("rgba32-1.bmp"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::BMPImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::BMPImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_gif)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("download-animation.gif"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::GIFImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::GIFImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
Tests/LibGfx: Fix test_gif test case We should expect the GIF image to be animated, therefore fix that condition.
2023-01-20 16:41:21 +00:00
EXPECT(plugin_decoder->is_animated());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(1));
Tests/LibGfx: Actually test image decoders in TestImageDecoder We were passing raw Gfx::Bitmap objects into the various image decoders instead of encoded image data. This made all of them fail, but the test expectations were set up in a way that aligned with this outcome. With this patch, we now test the codecs for real. Except ICO, since we don't have an ICO file handy. That's a FIXME.
2021-11-11 10:20:58 +00:00
EXPECT(frame.duration == 400);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
LibGfx: Support BMP favicons with less than 32 bpp Adapt BMPImageDecoderPlugin to support BMP images included in ICOns. ICOImageDecoderPlugin now uses BMPImageDecoderPlugin to decode all BMP images instead of it's own ad-hoc decoder which only supported 32 bpp BMPs.
2022-12-18 18:13:19 +00:00
TEST_CASE(test_not_ico)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie.png"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(!MUST(Gfx::ICOImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::ICOImageDecoderPlugin::create(file->bytes()));
EXPECT(!plugin_decoder->initialize());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame(0).is_error());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
LibGfx: Support BMP favicons with less than 32 bpp Adapt BMPImageDecoderPlugin to support BMP images included in ICOns. ICOImageDecoderPlugin now uses BMPImageDecoderPlugin to decode all BMP images instead of it's own ad-hoc decoder which only supported 32 bpp BMPs.
2022-12-18 18:13:19 +00:00
TEST_CASE(test_bmp_embedded_in_ico)
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("serenity.ico"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::ICOImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::ICOImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
LibGfx: Support BMP favicons with less than 32 bpp Adapt BMPImageDecoderPlugin to support BMP images included in ICOns. ICOImageDecoderPlugin now uses BMPImageDecoderPlugin to decode all BMP images instead of it's own ad-hoc decoder which only supported 32 bpp BMPs.
2022-12-18 18:13:19 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
LibGfx: Support BMP favicons with less than 32 bpp Adapt BMPImageDecoderPlugin to support BMP images included in ICOns. ICOImageDecoderPlugin now uses BMPImageDecoderPlugin to decode all BMP images instead of it's own ad-hoc decoder which only supported 32 bpp BMPs.
2022-12-18 18:13:19 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(!plugin_decoder->frame(0).is_error());
LibGfx: Support BMP favicons with less than 32 bpp Adapt BMPImageDecoderPlugin to support BMP images included in ICOns. ICOImageDecoderPlugin now uses BMPImageDecoderPlugin to decode all BMP images instead of it's own ad-hoc decoder which only supported 32 bpp BMPs.
2022-12-18 18:13:19 +00:00
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_jpg)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("rgb24.jpg"sv)));
LibGfx: Rename `JPGLoader` to `JPEGLoader` The patch also contains modifications on several classes, functions or files that are related to the `JPGLoader`. Renaming include: - JPGLoader{.h, .cpp} - JPGImageDecoderPlugin - JPGLoadingContext - JPG_DEBUG - decode_jpg - FuzzJPGLoader.cpp - Few string literals or texts
2023-02-18 21:09:16 +00:00
EXPECT(MUST(Gfx::JPEGImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::JPEGImageDecoderPlugin::create(file->bytes()));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(plugin_decoder->initialize());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_pbm)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-raw.pbm"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::PBMImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::PBMImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_pgm)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-raw.pgm"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::PGMImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::PGMImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_png)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie.png"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::PNGImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::PNGImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
TEST_CASE(test_ppm)
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-raw.ppm"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::PPMImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::PPMImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT(plugin_decoder->frame_count());
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests: Convert LibGfx image decoder test to be LibTest based.
2021-04-29 01:38:16 +00:00
EXPECT(frame.duration == 0);
Tests: Add Tests/LibGfx/image-decoder tests
2021-02-01 09:03:04 +00:00
}
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
TEST_CASE(test_targa_bottom_left)
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-bottom-left-uncompressed.tga"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::TGAImageDecoderPlugin::validate_before_create(file->bytes())));
auto plugin_decoder = MUST(Gfx::TGAImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
EXPECT(frame.duration == 0);
}
TEST_CASE(test_targa_top_left)
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-top-left-uncompressed.tga"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::TGAImageDecoderPlugin::validate_before_create(file->bytes())));
auto plugin_decoder = MUST(Gfx::TGAImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests/LibGfx: Add tests for top-left and bottom-left TGA images
2022-12-31 11:34:05 +00:00
EXPECT(frame.duration == 0);
}
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
TEST_CASE(test_targa_bottom_left_compressed)
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-bottom-left-compressed.tga"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::TGAImageDecoderPlugin::validate_before_create(file->bytes())));
auto plugin_decoder = MUST(Gfx::TGAImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
EXPECT(frame.duration == 0);
}
TEST_CASE(test_targa_top_left_compressed)
{
LibGfx: Move TestImageDecoder over to input file approach in 8cfabbcd933 Rather than reading files out of /res, put them in a subfolder of Tests/LibGfx/ and pick the path based on AK_OS_SERENITY. That way, the tests can also pass when run under lagom. (I just `cp`d all the files that the test previously read from random places into Tests/LibGfx/test-inputs.)
2023-01-31 19:00:33 +00:00
auto file = MUST(Core::MappedFile::map(TEST_INPUT("buggie-top-left-compressed.tga"sv)));
Tests: Modernize TestImageDecoder a bit - Use MUST() instead of checking plugin_decoder_or_error.is_error() - Use MappedFile::bytes() - Don't use EXPECT_EQ when comparing to fixed bools No intended behavior change.
2023-01-29 22:21:24 +00:00
EXPECT(MUST(Gfx::TGAImageDecoderPlugin::validate_before_create(file->bytes())));
auto plugin_decoder = MUST(Gfx::TGAImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
LibGfx: Re-structure the whole initialization pattern for image decoders When trying to figure out the correct implementation, we now have a very strong distinction on plugins that are well suited for sniffing, and plugins that need a MIME type to be chosen. Instead of having multiple calls to non-static virtual sniff methods for each Image decoding plugin, we have 2 static methods for each implementation: 1. The sniff method, which in contrast to the old method, gets a ReadonlyBytes parameter and ensures we can figure out the result with zero heap allocations for most implementations. 2. The create method, which just creates a new instance so we don't expose the constructor to everyone anymore. In addition to that, we have a new virtual method called initialize, which has a per-implementation initialization pattern to actually ensure each implementation can construct a decoder object, and then have a correct context being applied to it for the actual decoding.
2023-01-20 08:13:14 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
Tests: Use MUST more in TestImageDecoder No behavior change.
2023-02-25 23:58:19 +00:00
auto frame = MUST(plugin_decoder->frame(0));
Tests/LibGfx: Add tests for compressed TGA images
2023-01-07 15:02:00 +00:00
EXPECT(frame.duration == 0);
}
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
TEST_CASE(test_webp_simple_lossy)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("simple-vp8.webp"sv)));
EXPECT(MUST(Gfx::WebPImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(240, 240));
}
TEST_CASE(test_webp_simple_lossless)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("simple-vp8l.webp"sv)));
EXPECT(MUST(Gfx::WebPImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(386, 395));
}
TEST_CASE(test_webp_extended_lossy)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("extended-lossy.webp"sv)));
EXPECT(MUST(Gfx::WebPImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(417, 223));
}
TEST_CASE(test_webp_extended_lossless)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("extended-lossless.webp"sv)));
EXPECT(MUST(Gfx::WebPImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
EXPECT_EQ(plugin_decoder->frame_count(), 1u);
EXPECT(!plugin_decoder->is_animated());
EXPECT(!plugin_decoder->loop_count());
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(417, 223));
}
TEST_CASE(test_webp_extended_lossless_animated)
{
auto file = MUST(Core::MappedFile::map(TEST_INPUT("extended-lossless-animated.webp"sv)));
EXPECT(MUST(Gfx::WebPImageDecoderPlugin::sniff(file->bytes())));
auto plugin_decoder = MUST(Gfx::WebPImageDecoderPlugin::create(file->bytes()));
EXPECT(plugin_decoder->initialize());
LibGfx: Implement is_animated() and frame_count() for webp plugin
2023-02-26 03:15:34 +00:00
EXPECT_EQ(plugin_decoder->frame_count(), 8u);
EXPECT(plugin_decoder->is_animated());
LibGfx: Implement WebPImageDecoderPlugin::loop_count() Turns out extended-lossless-animated.webp did have a loop count of 0. So I opened it in Hex Fiend and changed the byte at position 42 (which is the first byte of the little-endian u16 storing the loop count) to 0x2A, so that the test can compare the loop count to something not 0.
2023-02-26 14:13:27 +00:00
EXPECT_EQ(plugin_decoder->loop_count(), 42u);
Tests: Add webp size decoding tests for webp
2023-02-26 00:27:09 +00:00
EXPECT_EQ(plugin_decoder->size(), Gfx::IntSize(990, 1050));
}
Reference in a new issue Copy permalink