1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 #ifndef mozilla_image_test_gtest_Common_h
7 #define mozilla_image_test_gtest_Common_h
11 #include "gtest/gtest.h"
13 #include "mozilla/Attributes.h"
14 #include "mozilla/gtest/MozAssertions.h"
15 #include "mozilla/Maybe.h"
16 #include "mozilla/UniquePtr.h"
17 #include "mozilla/gfx/2D.h"
20 #include "gfxPlatform.h"
22 #include "SurfaceFlags.h"
23 #include "SurfacePipe.h"
24 #include "SurfacePipeFactory.h"
31 ///////////////////////////////////////////////////////////////////////////////
33 ///////////////////////////////////////////////////////////////////////////////
36 BGRAColor() : BGRAColor(0, 0, 0, 0) {}
38 BGRAColor(uint8_t aBlue
, uint8_t aGreen
, uint8_t aRed
, uint8_t aAlpha
,
39 bool aPremultiplied
= false, bool asRGB
= true)
44 mPremultiplied(aPremultiplied
),
47 static BGRAColor
Green() { return BGRAColor(0x00, 0xFF, 0x00, 0xFF); }
48 static BGRAColor
Red() { return BGRAColor(0x00, 0x00, 0xFF, 0xFF); }
49 static BGRAColor
Blue() { return BGRAColor(0xFF, 0x00, 0x00, 0xFF); }
50 static BGRAColor
Transparent() { return BGRAColor(0x00, 0x00, 0x00, 0x00); }
52 static BGRAColor
FromPixel(uint32_t aPixel
) {
54 r
= (aPixel
>> gfx::SurfaceFormatBit::OS_R
) & 0xFF;
55 g
= (aPixel
>> gfx::SurfaceFormatBit::OS_G
) & 0xFF;
56 b
= (aPixel
>> gfx::SurfaceFormatBit::OS_B
) & 0xFF;
57 a
= (aPixel
>> gfx::SurfaceFormatBit::OS_A
) & 0xFF;
58 return BGRAColor(b
, g
, r
, a
, true);
61 BGRAColor
DeviceColor() const {
62 MOZ_RELEASE_ASSERT(!mPremultiplied
);
64 gfx::DeviceColor color
= gfx::ToDeviceColor(
65 gfx::sRGBColor(float(mRed
) / 255.0f
, float(mGreen
) / 255.0f
,
66 float(mBlue
) / 255.0f
, 1.0));
67 return BGRAColor(uint8_t(color
.b
* 255.0f
), uint8_t(color
.g
* 255.0f
),
68 uint8_t(color
.r
* 255.0f
), mAlpha
, mPremultiplied
,
74 BGRAColor
sRGBColor() const {
75 MOZ_RELEASE_ASSERT(msRGB
);
76 MOZ_RELEASE_ASSERT(!mPremultiplied
);
80 BGRAColor
Premultiply() const {
81 if (!mPremultiplied
) {
82 return BGRAColor(gfxPreMultiply(mBlue
, mAlpha
),
83 gfxPreMultiply(mGreen
, mAlpha
),
84 gfxPreMultiply(mRed
, mAlpha
), mAlpha
, true);
89 uint32_t AsPixel() const {
90 if (!mPremultiplied
) {
91 return gfxPackedPixel(mAlpha
, mRed
, mGreen
, mBlue
);
93 return gfxPackedPixelNoPreMultiply(mAlpha
, mRed
, mGreen
, mBlue
);
105 TEST_CASE_DEFAULT_FLAGS
= 0,
106 TEST_CASE_IS_FUZZY
= 1 << 0,
107 TEST_CASE_HAS_ERROR
= 1 << 1,
108 TEST_CASE_IS_TRANSPARENT
= 1 << 2,
109 TEST_CASE_IS_ANIMATED
= 1 << 3,
110 TEST_CASE_IGNORE_OUTPUT
= 1 << 4,
111 TEST_CASE_ASSUME_SRGB_OUTPUT
= 1 << 5,
114 struct ImageTestCase
{
115 ImageTestCase(const char* aPath
, const char* aMimeType
, gfx::IntSize aSize
,
116 uint32_t aFlags
= TEST_CASE_DEFAULT_FLAGS
,
117 uint32_t aFrameCount
= 1)
119 mMimeType(aMimeType
),
122 mFrameCount(aFrameCount
),
124 mSurfaceFlags(DefaultSurfaceFlags()),
125 mColor(BGRAColor::Green()) {}
127 ImageTestCase(const char* aPath
, const char* aMimeType
, gfx::IntSize aSize
,
128 gfx::IntSize aOutputSize
,
129 uint32_t aFlags
= TEST_CASE_DEFAULT_FLAGS
)
131 mMimeType(aMimeType
),
133 mOutputSize(aOutputSize
),
135 mSurfaceFlags(DefaultSurfaceFlags()),
136 mColor(BGRAColor::Green()) {}
138 ImageTestCase
WithSurfaceFlags(SurfaceFlags aSurfaceFlags
) const {
139 ImageTestCase self
= *this;
140 self
.mSurfaceFlags
= aSurfaceFlags
;
144 ImageTestCase
WithFlags(uint32_t aFlags
) const {
145 ImageTestCase self
= *this;
146 self
.mFlags
= aFlags
;
150 BGRAColor
ChooseColor(const BGRAColor
& aColor
) const {
151 // If we are forcing the output to be sRGB via the surface flag, or the
152 // test case is marked as assuming sRGB (used when the image itself is not
153 // explicitly tagged, and as a result, imagelib won't perform any color
154 // conversion), we should use the sRGB presentation of the color.
155 if ((mSurfaceFlags
& SurfaceFlags::TO_SRGB_COLORSPACE
) ||
156 (mFlags
& TEST_CASE_ASSUME_SRGB_OUTPUT
)) {
157 return aColor
.sRGBColor();
159 return aColor
.DeviceColor();
162 BGRAColor
Color() const { return ChooseColor(mColor
); }
164 uint8_t Fuzz() const {
165 // If we are using device space, there can easily be off by 1 channel errors
166 // depending on the color profile and how the rounding went.
167 if (mFlags
& TEST_CASE_IS_FUZZY
||
168 !(mSurfaceFlags
& SurfaceFlags::TO_SRGB_COLORSPACE
)) {
175 const char* mMimeType
;
177 gfx::IntSize mOutputSize
;
178 uint32_t mFrameCount
= 0;
180 SurfaceFlags mSurfaceFlags
;
184 ///////////////////////////////////////////////////////////////////////////////
186 ///////////////////////////////////////////////////////////////////////////////
189 * A RAII class that ensure that ImageLib services are available. Any tests that
190 * require ImageLib to be initialized (for example, any test that uses the
191 * SurfaceCache; see image::EnsureModuleInitialized() for the full list) can
192 * use this class to ensure that ImageLib services are available. Failure to do
193 * so can result in strange, non-deterministic failures.
195 class AutoInitializeImageLib
{
197 AutoInitializeImageLib();
201 * A test fixture class used for benchmark tests. It preloads the image data
202 * from disk to avoid including that in the timing.
204 class ImageBenchmarkBase
: public ::testing::Test
{
206 ImageBenchmarkBase(const ImageTestCase
& aTestCase
) : mTestCase(aTestCase
) {}
208 void SetUp() override
;
209 void TearDown() override
;
211 AutoInitializeImageLib mInit
;
212 ImageTestCase mTestCase
;
213 RefPtr
<SourceBuffer
> mSourceBuffer
;
216 /// Spins on the main thread to process any pending events.
217 void SpinPendingEvents();
219 /// Loads a file from the current directory. @return an nsIInputStream for it.
220 already_AddRefed
<nsIInputStream
> LoadFile(const char* aRelativePath
);
223 * @returns true if every pixel of @aSurface is @aColor.
225 * If @aFuzz is nonzero, a tolerance of @aFuzz is allowed in each color
226 * component. This may be necessary for tests that involve JPEG images or
229 bool IsSolidColor(gfx::SourceSurface
* aSurface
, BGRAColor aColor
,
233 * @returns true if every pixel in the range of rows specified by @aStartRow and
234 * @aRowCount of @aSurface is @aColor.
236 * If @aFuzz is nonzero, a tolerance of @aFuzz is allowed in each color
237 * component. This may be necessary for tests that involve JPEG images or
240 bool RowsAreSolidColor(gfx::SourceSurface
* aSurface
, int32_t aStartRow
,
241 int32_t aRowCount
, BGRAColor aColor
, uint8_t aFuzz
= 0);
244 * @returns true if every pixel in the rect specified by @aRect is @aColor.
246 * If @aFuzz is nonzero, a tolerance of @aFuzz is allowed in each color
247 * component. This may be necessary for tests that involve JPEG images or
250 bool RectIsSolidColor(gfx::SourceSurface
* aSurface
, const gfx::IntRect
& aRect
,
251 BGRAColor aColor
, uint8_t aFuzz
= 0);
254 * @returns true if the pixels in @aRow of @aSurface match the pixels given in
257 bool RowHasPixels(gfx::SourceSurface
* aSurface
, int32_t aRow
,
258 const std::vector
<BGRAColor
>& aPixels
);
260 // ExpectNoResume is an IResumable implementation for use by tests that expect
261 // Resume() to never get called.
262 class ExpectNoResume final
: public IResumable
{
264 NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ExpectNoResume
, override
)
266 void Resume() override
{ FAIL() << "Resume() should not get called"; }
269 ~ExpectNoResume() override
{}
272 // CountResumes is an IResumable implementation for use by tests that expect
273 // Resume() to get called a certain number of times.
274 class CountResumes
: public IResumable
{
276 NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CountResumes
, override
)
278 CountResumes() : mCount(0) {}
280 void Resume() override
{ mCount
++; }
281 uint32_t Count() const { return mCount
; }
284 ~CountResumes() override
{}
289 ///////////////////////////////////////////////////////////////////////////////
290 // SurfacePipe Helpers
291 ///////////////////////////////////////////////////////////////////////////////
294 * Creates a decoder with no data associated with, suitable for testing code
295 * that requires a decoder to initialize or to allocate surfaces but doesn't
296 * actually need the decoder to do any decoding.
298 * XXX(seth): We only need this because SurfaceSink defer to the decoder for
299 * surface allocation. Once all decoders use SurfacePipe we won't need to do
300 * that anymore and we can remove this function.
302 already_AddRefed
<Decoder
> CreateTrivialDecoder();
305 * Creates a pipeline of SurfaceFilters from a list of Config structs and passes
306 * it to the provided lambda @aFunc. Assertions that the pipeline is constructly
307 * correctly and cleanup of any allocated surfaces is handled automatically.
309 * @param aDecoder The decoder to use for allocating surfaces.
310 * @param aFunc The lambda function to pass the filter pipeline to.
311 * @param aConfigs The configuration for the pipeline.
313 template <typename Func
, typename
... Configs
>
314 void WithFilterPipeline(Decoder
* aDecoder
, Func aFunc
, bool aFinish
,
315 const Configs
&... aConfigs
) {
316 auto pipe
= MakeUnique
<typename
detail::FilterPipeline
<Configs
...>::Type
>();
317 nsresult rv
= pipe
->Configure(aConfigs
...);
318 ASSERT_NS_SUCCEEDED(rv
);
320 aFunc(aDecoder
, pipe
.get());
323 RawAccessFrameRef currentFrame
= aDecoder
->GetCurrentFrameRef();
325 currentFrame
->Finish();
330 template <typename Func
, typename
... Configs
>
331 void WithFilterPipeline(Decoder
* aDecoder
, Func aFunc
,
332 const Configs
&... aConfigs
) {
333 WithFilterPipeline(aDecoder
, aFunc
, true, aConfigs
...);
337 * Creates a pipeline of SurfaceFilters from a list of Config structs and
338 * asserts that configuring it fails. Cleanup of any allocated surfaces is
339 * handled automatically.
341 * @param aDecoder The decoder to use for allocating surfaces.
342 * @param aConfigs The configuration for the pipeline.
344 template <typename
... Configs
>
345 void AssertConfiguringPipelineFails(Decoder
* aDecoder
,
346 const Configs
&... aConfigs
) {
347 auto pipe
= MakeUnique
<typename
detail::FilterPipeline
<Configs
...>::Type
>();
348 nsresult rv
= pipe
->Configure(aConfigs
...);
350 // Callers expect configuring the pipeline to fail.
351 ASSERT_NS_FAILED(rv
);
353 RawAccessFrameRef currentFrame
= aDecoder
->GetCurrentFrameRef();
355 currentFrame
->Finish();
360 * Asserts that the provided filter pipeline is in the correct final state,
361 * which is to say, the entire surface has been written to (IsSurfaceFinished()
362 * returns true) and the invalid rects are as expected.
364 * @param aFilter The filter pipeline to check.
365 * @param aInputSpaceRect The expect invalid rect, in input space.
366 * @param aoutputSpaceRect The expect invalid rect, in output space.
368 void AssertCorrectPipelineFinalState(SurfaceFilter
* aFilter
,
369 const gfx::IntRect
& aInputSpaceRect
,
370 const gfx::IntRect
& aOutputSpaceRect
);
373 * Checks a generated image for correctness. Reports any unexpected deviation
374 * from the expected image as GTest failures.
376 * @param aDecoder The decoder which contains the image. The decoder's current
377 * frame will be checked.
378 * @param aRect The region in the space of the output surface that the filter
379 * pipeline will actually write to. It's expected that pixels in
380 * this region are green, while pixels outside this region are
382 * @param aFuzz The amount of fuzz to use in pixel comparisons.
384 void CheckGeneratedImage(Decoder
* aDecoder
, const gfx::IntRect
& aRect
,
388 * Checks a generated surface for correctness. Reports any unexpected deviation
389 * from the expected image as GTest failures.
391 * @param aSurface The surface to check.
392 * @param aRect The region in the space of the output surface that the filter
393 * pipeline will actually write to.
394 * @param aInnerColor Check that pixels inside of aRect are this color.
395 * @param aOuterColor Check that pixels outside of aRect are this color.
396 * @param aFuzz The amount of fuzz to use in pixel comparisons.
398 void CheckGeneratedSurface(gfx::SourceSurface
* aSurface
,
399 const gfx::IntRect
& aRect
,
400 const BGRAColor
& aInnerColor
,
401 const BGRAColor
& aOuterColor
, uint8_t aFuzz
= 0);
404 * Tests the result of calling WritePixels() using the provided SurfaceFilter
405 * pipeline. The pipeline must be a normal (i.e., non-paletted) pipeline.
407 * The arguments are specified in the an order intended to minimize the number
408 * of arguments that most test cases need to pass.
410 * @param aDecoder The decoder whose current frame will be written to.
411 * @param aFilter The SurfaceFilter pipeline to use.
412 * @param aOutputRect The region in the space of the output surface that will be
413 * invalidated by the filter pipeline. Defaults to
415 * @param aInputRect The region in the space of the input image that will be
416 * invalidated by the filter pipeline. Defaults to
418 * @param aInputWriteRect The region in the space of the input image that the
419 * filter pipeline will allow writes to. Note the
420 * difference from @aInputRect: @aInputRect is the actual
421 * region invalidated, while @aInputWriteRect is the
422 * region that is written to. These can differ in cases
423 * where the input is not clipped to the size of the
424 * image. Defaults to the entire input rect.
425 * @param aOutputWriteRect The region in the space of the output surface that
426 * the filter pipeline will actually write to. It's
427 * expected that pixels in this region are green, while
428 * pixels outside this region are transparent. Defaults
429 * to the entire output rect.
431 void CheckWritePixels(Decoder
* aDecoder
, SurfaceFilter
* aFilter
,
432 const Maybe
<gfx::IntRect
>& aOutputRect
= Nothing(),
433 const Maybe
<gfx::IntRect
>& aInputRect
= Nothing(),
434 const Maybe
<gfx::IntRect
>& aInputWriteRect
= Nothing(),
435 const Maybe
<gfx::IntRect
>& aOutputWriteRect
= Nothing(),
439 * Tests the result of calling WritePixels() using the provided SurfaceFilter
440 * pipeline. Allows for control over the input color to write, and the expected
442 * @see CheckWritePixels() for documentation of the arguments.
444 void CheckTransformedWritePixels(
445 Decoder
* aDecoder
, SurfaceFilter
* aFilter
, const BGRAColor
& aInputColor
,
446 const BGRAColor
& aOutputColor
,
447 const Maybe
<gfx::IntRect
>& aOutputRect
= Nothing(),
448 const Maybe
<gfx::IntRect
>& aInputRect
= Nothing(),
449 const Maybe
<gfx::IntRect
>& aInputWriteRect
= Nothing(),
450 const Maybe
<gfx::IntRect
>& aOutputWriteRect
= Nothing(), uint8_t aFuzz
= 0);
452 ///////////////////////////////////////////////////////////////////////////////
454 ///////////////////////////////////////////////////////////////////////////////
456 // Friend class of Decoder to access internals for tests.
457 class MOZ_STACK_CLASS DecoderTestHelper final
{
459 explicit DecoderTestHelper(Decoder
* aDecoder
) : mDecoder(aDecoder
) {}
461 void PostIsAnimated(FrameTimeout aTimeout
) {
462 mDecoder
->PostIsAnimated(aTimeout
);
465 void PostFrameStop(Opacity aOpacity
) { mDecoder
->PostFrameStop(aOpacity
); }
471 ///////////////////////////////////////////////////////////////////////////////
473 ///////////////////////////////////////////////////////////////////////////////
475 ImageTestCase
GreenPNGTestCase();
476 ImageTestCase
GreenGIFTestCase();
477 ImageTestCase
GreenJPGTestCase();
478 ImageTestCase
GreenBMPTestCase();
479 ImageTestCase
GreenICOTestCase();
480 ImageTestCase
GreenIconTestCase();
481 ImageTestCase
GreenWebPTestCase();
482 ImageTestCase
GreenAVIFTestCase();
484 ImageTestCase
NonzeroReservedAVIFTestCase();
485 ImageTestCase
MultipleColrAVIFTestCase();
486 ImageTestCase
Transparent10bit420AVIFTestCase();
487 ImageTestCase
Transparent10bit422AVIFTestCase();
488 ImageTestCase
Transparent10bit444AVIFTestCase();
489 ImageTestCase
Transparent12bit420AVIFTestCase();
490 ImageTestCase
Transparent12bit422AVIFTestCase();
491 ImageTestCase
Transparent12bit444AVIFTestCase();
492 ImageTestCase
Transparent8bit420AVIFTestCase();
493 ImageTestCase
Transparent8bit422AVIFTestCase();
494 ImageTestCase
Transparent8bit444AVIFTestCase();
496 ImageTestCase
Gray8bitLimitedRangeBT601AVIFTestCase();
497 ImageTestCase
Gray8bitLimitedRangeBT709AVIFTestCase();
498 ImageTestCase
Gray8bitLimitedRangeBT2020AVIFTestCase();
499 ImageTestCase
Gray8bitFullRangeBT601AVIFTestCase();
500 ImageTestCase
Gray8bitFullRangeBT709AVIFTestCase();
501 ImageTestCase
Gray8bitFullRangeBT2020AVIFTestCase();
502 ImageTestCase
Gray10bitLimitedRangeBT601AVIFTestCase();
503 ImageTestCase
Gray10bitLimitedRangeBT709AVIFTestCase();
504 ImageTestCase
Gray10bitLimitedRangeBT2020AVIFTestCase();
505 ImageTestCase
Gray10bitFullRangeBT601AVIFTestCase();
506 ImageTestCase
Gray10bitFullRangeBT709AVIFTestCase();
507 ImageTestCase
Gray10bitFullRangeBT2020AVIFTestCase();
508 ImageTestCase
Gray12bitLimitedRangeBT601AVIFTestCase();
509 ImageTestCase
Gray12bitLimitedRangeBT709AVIFTestCase();
510 ImageTestCase
Gray12bitLimitedRangeBT2020AVIFTestCase();
511 ImageTestCase
Gray12bitFullRangeBT601AVIFTestCase();
512 ImageTestCase
Gray12bitFullRangeBT709AVIFTestCase();
513 ImageTestCase
Gray12bitFullRangeBT2020AVIFTestCase();
514 ImageTestCase
Gray8bitLimitedRangeGrayscaleAVIFTestCase();
515 ImageTestCase
Gray8bitFullRangeGrayscaleAVIFTestCase();
516 ImageTestCase
Gray10bitLimitedRangeGrayscaleAVIFTestCase();
517 ImageTestCase
Gray10bitFullRangeGrayscaleAVIFTestCase();
518 ImageTestCase
Gray12bitLimitedRangeGrayscaleAVIFTestCase();
519 ImageTestCase
Gray12bitFullRangeGrayscaleAVIFTestCase();
521 ImageTestCase
StackCheckAVIFTestCase();
523 ImageTestCase
LargeWebPTestCase();
524 ImageTestCase
GreenWebPIccSrgbTestCase();
526 ImageTestCase
GreenFirstFrameAnimatedGIFTestCase();
527 ImageTestCase
GreenFirstFrameAnimatedPNGTestCase();
528 ImageTestCase
GreenFirstFrameAnimatedWebPTestCase();
529 ImageTestCase
GreenFirstFrameAnimatedAVIFTestCase();
531 ImageTestCase
BlendAnimatedGIFTestCase();
532 ImageTestCase
BlendAnimatedPNGTestCase();
533 ImageTestCase
BlendAnimatedWebPTestCase();
534 ImageTestCase
BlendAnimatedAVIFTestCase();
536 ImageTestCase
CorruptTestCase();
537 ImageTestCase
CorruptBMPWithTruncatedHeader();
538 ImageTestCase
CorruptICOWithBadBMPWidthTestCase();
539 ImageTestCase
CorruptICOWithBadBMPHeightTestCase();
540 ImageTestCase
CorruptICOWithBadBppTestCase();
542 ImageTestCase
TransparentPNGTestCase();
543 ImageTestCase
TransparentGIFTestCase();
544 ImageTestCase
TransparentWebPTestCase();
545 ImageTestCase
TransparentNoAlphaHeaderWebPTestCase();
546 ImageTestCase
FirstFramePaddingGIFTestCase();
547 ImageTestCase
TransparentIfWithinICOBMPTestCase(TestCaseFlags aFlags
);
548 ImageTestCase
NoFrameDelayGIFTestCase();
549 ImageTestCase
ExtraImageSubBlocksAnimatedGIFTestCase();
551 ImageTestCase
TransparentBMPWhenBMPAlphaEnabledTestCase();
552 ImageTestCase
RLE4BMPTestCase();
553 ImageTestCase
RLE8BMPTestCase();
555 ImageTestCase
DownscaledPNGTestCase();
556 ImageTestCase
DownscaledGIFTestCase();
557 ImageTestCase
DownscaledJPGTestCase();
558 ImageTestCase
DownscaledBMPTestCase();
559 ImageTestCase
DownscaledICOTestCase();
560 ImageTestCase
DownscaledIconTestCase();
561 ImageTestCase
DownscaledWebPTestCase();
562 ImageTestCase
DownscaledTransparentICOWithANDMaskTestCase();
564 ImageTestCase
TruncatedSmallGIFTestCase();
566 ImageTestCase
LargeICOWithBMPTestCase();
567 ImageTestCase
LargeICOWithPNGTestCase();
568 ImageTestCase
GreenMultipleSizesICOTestCase();
570 ImageTestCase
PerfGrayJPGTestCase();
571 ImageTestCase
PerfCmykJPGTestCase();
572 ImageTestCase
PerfYCbCrJPGTestCase();
573 ImageTestCase
PerfRgbPNGTestCase();
574 ImageTestCase
PerfRgbAlphaPNGTestCase();
575 ImageTestCase
PerfGrayPNGTestCase();
576 ImageTestCase
PerfGrayAlphaPNGTestCase();
577 ImageTestCase
PerfRgbLosslessWebPTestCase();
578 ImageTestCase
PerfRgbAlphaLosslessWebPTestCase();
579 ImageTestCase
PerfRgbLossyWebPTestCase();
580 ImageTestCase
PerfRgbAlphaLossyWebPTestCase();
581 ImageTestCase
PerfRgbGIFTestCase();
583 ImageTestCase
CorruptAVIFTestCase();
584 ImageTestCase
DownscaledAVIFTestCase();
585 ImageTestCase
LargeAVIFTestCase();
586 ImageTestCase
MultiLayerAVIFTestCase();
587 ImageTestCase
TransparentAVIFTestCase();
590 ImageTestCase
GreenJXLTestCase();
591 ImageTestCase
DownscaledJXLTestCase();
592 ImageTestCase
LargeJXLTestCase();
593 ImageTestCase
TransparentJXLTestCase();
596 ImageTestCase
ExifResolutionTestCase();
598 RefPtr
<Image
> TestCaseToDecodedImage(const ImageTestCase
&);
601 } // namespace mozilla
603 #endif // mozilla_image_test_gtest_Common_h