ILIAS\Filesystem\Util\ImageConversionTest Class Reference

Inheritance diagram for ILIAS\Filesystem\Util\ImageConversionTest:

Collaboration diagram for ILIAS\Filesystem\Util\ImageConversionTest:

Public Member Functions
	testImageThumbnailActualImage ()
	testImageSquareActualImage ()
	testResizeToFitWidth (int $width, int $height, int $final_width, int $final_height)
	testResizeToFitHeight (int $width, int $height, int $final_height, int $final_width)
	testResizeByFixedSize (int $width, int $height, int $final_width, int $final_height, bool $crop)
	testImageOutputOptions (ImageOutputOptions $options, string $expected_mime_type, int $expected_quality)
	testImageOutputOptionSanity ()
	testWrongFormats (string $format)
	testWrongQualities (int $quality)
	testFormatConvert ()
	testFailed ()
	testBackgroundColor (?string $color)
	testWriteImage ()
	testHighDensityPixel ()

Static Public Member Functions
static	getImageSizesByWidth ()
static	getImageSizesByHeight ()
static	getImageSizesByFixed ()
static	getImageOptions ()
static	getWrongFormats ()
static	getWrongQualites ()
static	getColors ()

Protected Member Functions
	setUp ()
	checkImagick ()
	getImageSizeFromStream (FileStream $stream)
	getImageTypeFromStream (FileStream $stream)
	getImageQualityFromStream (FileStream $stream)
	createTestImageStream (int $width, int $height)

Protected Attributes
const	BY_WIDTH_FINAL = 256
const	BY_HEIGHT_FINAL = 756
const	W = 'width'
const	H = 'height'
const	IMAGE_JPEG = 'image/jpeg'
const	IMAGE_PNG = 'image/png'
const	IMAGE_WEBP = 'image/webp'
Images	$images

Private Member Functions
	colorDiff (string $hex_color_one, string $hex_color_two)

Detailed Description

Author

Fabian Schmid fabia.nosp@m.n@sr.nosp@m..solu.nosp@m.tion.nosp@m.s

Definition at line 33 of file ImageConversionTest.php.

Member Function Documentation

checkImagick()

ILIAS\Filesystem\Util\ImageConversionTest::checkImagick ( )

protected

Definition at line 482 of file ImageConversionTest.php.

                                     : void
    {
        if (!class_exists('Imagick')) {
            $this->markTestSkipped('Imagick not installed');
        }
    }

Referenced by ILIAS\Filesystem\Util\ImageConversionTest\setUp().

Here is the caller graph for this function:

colorDiff()

ILIAS\Filesystem\Util\ImageConversionTest::colorDiff ( string  $hex_color_one, string  $hex_color_two  )

private

Definition at line 385 of file ImageConversionTest.php.

                                                                            : int
    {
        preg_match('/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i', $hex_color_one, $rgb_one);
        preg_match('/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i', $hex_color_two, $rgb_two);
 
        return abs(hexdec($rgb_one[1]) - hexdec($rgb_two[1]))
            + abs(hexdec($rgb_one[2]) - hexdec($rgb_two[2]))
            + abs(hexdec($rgb_one[3]) - hexdec($rgb_two[3]));
    }

createTestImageStream()

ILIAS\Filesystem\Util\ImageConversionTest::createTestImageStream ( int  $width, int  $height  )

protected

Definition at line 512 of file ImageConversionTest.php.

                                                                     : FileStream
    {
        $img = new \Imagick();
        $img->newImage($width, $height, new \ImagickPixel('black'));
        $img->setImageFormat('jpg');
 
        $stream = Streams::ofString($img->getImageBlob());
        $stream->rewind();
        return $stream;
    }

getColors()

static ILIAS\Filesystem\Util\ImageConversionTest::getColors ( )

static

Definition at line 369 of file ImageConversionTest.php.

                                      : \Iterator
    {
        yield [null];
        yield ['#000000'];
        yield ['#ff0000'];
        yield ['#00ff00'];
        yield ['#0000ff'];
        yield ['#ffffff'];
        yield ['#A3BF5A'];
        yield ['#E9745A'];
        yield ['#5A5AE9'];
        yield ['#5AE9E9'];
        yield ['#E95AE9'];
        yield ['#E9E95A'];
    }

getImageOptions()

static ILIAS\Filesystem\Util\ImageConversionTest::getImageOptions ( )

static

Definition at line 233 of file ImageConversionTest.php.

                                            : \Iterator
    {
        $options = new ImageOutputOptions();
        yield [$options, self::IMAGE_JPEG, 75];
        yield [$options->withPngOutput()->withQuality(22), self::IMAGE_PNG, 0];
        yield [$options->withJpgOutput()->withQuality(100), self::IMAGE_JPEG, 100];
        yield [$options->withFormat('png')->withQuality(50), self::IMAGE_PNG, 0];
        yield [$options->withFormat('jpg')->withQuality(87), self::IMAGE_JPEG, 87];
        yield [$options->withQuality(5)->withJpgOutput(), self::IMAGE_JPEG, 5];
        yield [$options->withQuality(10)->withJpgOutput(), self::IMAGE_JPEG, 10];
        yield [$options->withQuality(35)->withJpgOutput(), self::IMAGE_JPEG, 35];
        yield [$options->withQuality(0)->withWebPOutput(), self::IMAGE_WEBP, 0];
        yield [$options->withQuality(100)->withWebPOutput(), self::IMAGE_WEBP, 100];
    }

References ILIAS\UI\Implementation\Component\Input\Field\$options.

getImageQualityFromStream()

ILIAS\Filesystem\Util\ImageConversionTest::getImageQualityFromStream ( FileStream  $stream )

protected

Definition at line 503 of file ImageConversionTest.php.

                                                                    : int
    {
        $stream->rewind();
        $img = new \Imagick();
        $img->readImageBlob((string) $stream);
 
        return $img->getImageCompressionQuality();
    }

getImageSizeFromStream()

ILIAS\Filesystem\Util\ImageConversionTest::getImageSizeFromStream ( FileStream  $stream )

protected

Definition at line 489 of file ImageConversionTest.php.

                                                                 : array
    {
        $getimagesizefromstring = getimagesizefromstring((string) $stream);
        return [
            self::W => (int) round($getimagesizefromstring[0]),
            self::H => (int) round($getimagesizefromstring[1])
        ];
    }

References ILIAS\Repository\int().

Referenced by ILIAS\Filesystem\Util\ImageConversionTest\testImageSquareActualImage().

Here is the call graph for this function:

Here is the caller graph for this function:

getImageSizesByFixed()

static ILIAS\Filesystem\Util\ImageConversionTest::getImageSizesByFixed ( )

static

Definition at line 202 of file ImageConversionTest.php.

                                                 : \Iterator
    {
        yield [1024, 768, 300, 100, true];
        yield [1024, 768, 300, 100, false];
        yield [1024, 768, 100, 300, true];
        yield [1024, 768, 100, 300, false];
        yield [400, 300, 500, 400, true];
        yield [400, 300, 500, 400, false];
    }

getImageSizesByHeight()

static ILIAS\Filesystem\Util\ImageConversionTest::getImageSizesByHeight ( )

static

Definition at line 154 of file ImageConversionTest.php.

                                                  : \Iterator
    {
        yield [400, 300, self::BY_HEIGHT_FINAL, 1008];
        yield [300, 400, self::BY_HEIGHT_FINAL, 567];
        yield [200, 200, self::BY_HEIGHT_FINAL, 756];
        yield [248, 845, self::BY_HEIGHT_FINAL, 221];
    }

getImageSizesByWidth()

static ILIAS\Filesystem\Util\ImageConversionTest::getImageSizesByWidth ( )

static

Definition at line 107 of file ImageConversionTest.php.

                                                 : \Iterator
    {
        yield [400, 300, self::BY_WIDTH_FINAL, 192];
        yield [300, 400, self::BY_WIDTH_FINAL, 341];
        yield [543, 431, self::BY_WIDTH_FINAL, 203];
        yield [200, 200, self::BY_WIDTH_FINAL, 256];
    }

References ILIAS\Filesystem\Util\ImageConversionTest\BY_WIDTH_FINAL.

getImageTypeFromStream()

ILIAS\Filesystem\Util\ImageConversionTest::getImageTypeFromStream ( FileStream  $stream )

protected

Definition at line 498 of file ImageConversionTest.php.

                                                                 : string
    {
        return finfo_buffer(finfo_open(FILEINFO_MIME_TYPE), $stream->read(255));
    }

getWrongFormats()

static ILIAS\Filesystem\Util\ImageConversionTest::getWrongFormats ( )

static

Definition at line 294 of file ImageConversionTest.php.

                                            : \Iterator
    {
        yield ['gif'];
        yield ['bmp'];
        yield ['jpg2000'];
    }

getWrongQualites()

static ILIAS\Filesystem\Util\ImageConversionTest::getWrongQualites ( )

static

Definition at line 309 of file ImageConversionTest.php.

                                             : \Iterator
    {
        yield [-1];
        yield [101];
        yield [102];
    }

setUp()

ILIAS\Filesystem\Util\ImageConversionTest::setUp ( )

protected

Definition at line 46 of file ImageConversionTest.php.

                              : void
    {
        $this->checkImagick();
        $this->images = new Images(
            true,
        );
    }

References ILIAS\Filesystem\Util\ImageConversionTest\checkImagick().

Here is the call graph for this function:

testBackgroundColor()

ILIAS\Filesystem\Util\ImageConversionTest::testBackgroundColor

(

?string

$color

)

Definition at line 396 of file ImageConversionTest.php.

                                                       : void
    {
        $transparent_png = __DIR__ . '/img/transparent.png';
        $this->assertFileExists($transparent_png);
        $png = Streams::ofResource(fopen($transparent_png, 'rb'));
 
        $converter_options = (new ImageConversionOptions())
            ->withThrowOnError(true)
            ->withFixedDimensions(100, 100);
 
        if ($color !== null) {
            $converter_options = $converter_options->withBackgroundColor($color);
        } else {
            $color = '#ffffff';
        }
 
        $output_options = (new ImageOutputOptions())
            ->withQuality(100)
            ->withJpgOutput();
 
        $converter = new ImageConverter($converter_options, $output_options, $png);
        $this->assertTrue($converter->isOK());
        $converted_stream = $converter->getStream();
        $gd_image = imagecreatefromstring((string) $converted_stream);
        $colors = imagecolorsforindex($gd_image, imagecolorat($gd_image, 1, 1));
 
        $color_in_converted_picture = sprintf("#%02x%02x%02x", $colors['red'], $colors['green'], $colors['blue']);
        $color_diff = $this->colorDiff($color, $color_in_converted_picture);
 
        $this->assertLessThan(3, $color_diff);
    }

testFailed()

ILIAS\Filesystem\Util\ImageConversionTest::testFailed

(

)

Definition at line 352 of file ImageConversionTest.php.

                                : void
    {
        $false_stream = Streams::ofString('false');
        $images = new Images(
            false,
            false
        );
 
        $resized = $images->resizeToFixedSize(
            $false_stream,
            5,
            5
        );
        $this->assertFalse($resized->isOK());
        $this->assertInstanceOf(\Throwable::class, $resized->getThrowableIfAny());
    }

References ILIAS\Filesystem\Util\Convert\Images\resizeToFixedSize().

Here is the call graph for this function:

testFormatConvert()

ILIAS\Filesystem\Util\ImageConversionTest::testFormatConvert

(

)

Definition at line 324 of file ImageConversionTest.php.

                                       : void
    {
        $jpg = $this->createTestImageStream(10, 10);
        $png = $this->images->convertToFormat(
            $jpg,
            'png'
        );
 
        $this->assertSame(self::IMAGE_PNG, $this->getImageTypeFromStream($png->getStream()));
        $size = $this->getImageSizeFromStream($png->getStream());
        $this->assertEquals(10, $size[self::W]);
        $this->assertEquals(10, $size[self::H]);
 
        // With Dimensions
        $jpg = $this->createTestImageStream(10, 10);
        $png = $this->images->convertToFormat(
            $jpg,
            'png',
            20,
            20
        );
 
        $this->assertSame(self::IMAGE_PNG, $this->getImageTypeFromStream($png->getStream()));
        $size = $this->getImageSizeFromStream($png->getStream());
        $this->assertEquals(20, $size[self::W]);
        $this->assertEquals(20, $size[self::H]);
    }

testHighDensityPixel()

ILIAS\Filesystem\Util\ImageConversionTest::testHighDensityPixel

(

)

Definition at line 453 of file ImageConversionTest.php.

                                          : void
    {
        $file = 'https://upload.wikimedia.org/wikipedia/commons/5/5e/Jan_Vermeer_-_The_Art_of_Painting_-_Google_Art_Project.jpg';
        $curl = curl_init();
        curl_setopt($curl, CURLOPT_URL, $file);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curl, CURLOPT_USERAGENT, 'PHPUnit/1.0');
        $string = curl_exec($curl);
        curl_close($curl);
 
        $img = Streams::ofString($string);
        $this->assertInstanceOf(FileStream::class, $img);
 
        $converter_options = (new ImageConversionOptions())
            ->withWidth(80)
            ->withHeight(80)
            ->withKeepAspectRatio(true)
            ->withCrop(true)
            ->withThrowOnError(true);
 
        $output_options = (new ImageOutputOptions())
            ->withQuality(60)
            ->withFormat(ImageOutputOptions::FORMAT_PNG);
 
        $converter = new ImageConverter($converter_options, $output_options, $img);
        $this->assertTrue($converter->isOK());
    }

testImageOutputOptions()

ILIAS\Filesystem\Util\ImageConversionTest::testImageOutputOptions	(	ImageOutputOptions	$options,
		string	$expected_mime_type,
		int	$expected_quality
	)

Definition at line 250 of file ImageConversionTest.php.

     : void {
        $resized = $this->images->resizeToFixedSize(
            $this->createTestImageStream(10, 10),
            5,
            5,
            true,
            $options
        );
 
        $this->assertSame($expected_mime_type, $this->getImageTypeFromStream($resized->getStream()));
        $this->assertSame($expected_quality, $this->getImageQualityFromStream($resized->getStream()));
    }

testImageOutputOptionSanity()

ILIAS\Filesystem\Util\ImageConversionTest::testImageOutputOptionSanity

(

)

Definition at line 267 of file ImageConversionTest.php.

                                                 : void
    {
        $options = new ImageOutputOptions();
 
        // Defaults
        $this->assertSame('jpg', $options->getFormat());
        $this->assertSame(75, $options->getQuality());
 
        $png = $options->withPngOutput();
        $this->assertSame('png', $png->getFormat());
        $this->assertSame('jpg', $options->getFormat()); // original options should not change
        $png_explicit = $options->withFormat('png');
        $this->assertSame('png', $png_explicit->getFormat());
 
        $jpg = $options->withJpgOutput();
        $this->assertSame('jpg', $jpg->getFormat());
        $jpg_explicit = $options->withFormat('jpg');
        $this->assertSame('jpg', $jpg_explicit->getFormat());
        $jpeg = $options->withFormat('jpeg');
        $this->assertSame('jpg', $jpeg->getFormat());
 
        // Quality
        $low = $options->withQuality(5);
        $this->assertSame(5, $low->getQuality());
        $this->assertSame(75, $options->getQuality()); // original options should not change
    }

References ILIAS\UI\Implementation\Component\Input\Field\$options.

testImageSquareActualImage()

ILIAS\Filesystem\Util\ImageConversionTest::testImageSquareActualImage

(

)

Definition at line 81 of file ImageConversionTest.php.

                                                : void
    {
        $img = __DIR__ . '/img/robot.jpg';
        $this->assertFileExists($img);
        $getimagesize = getimagesize($img);
        $original_width = $getimagesize[0]; // should be 600
        $original_height = $getimagesize[1]; // should be 800
        $this->assertSame(600, $original_width);
        $this->assertSame(800, $original_height);
 
        // make tumbnail
        $original_stream = Streams::ofResource(fopen($img, 'rb'));
 
        $thumbnail_converter = $this->images->croppedSquare(
            $original_stream,
            200
        );
        $this->assertTrue($thumbnail_converter->isOK());
        $this->assertNotInstanceOf(\Throwable::class, $thumbnail_converter->getThrowableIfAny());
 
        $getimagesizefromstring = $this->getImageSizeFromStream($thumbnail_converter->getStream());
 
        $this->assertEquals(200, $getimagesizefromstring[self::W]);
        $this->assertEquals(200, $getimagesizefromstring[self::H]);
    }

References ILIAS\Filesystem\Util\ImageConversionTest\getImageSizeFromStream(), and ILIAS\Filesystem\Stream\Streams\ofResource().

Here is the call graph for this function:

testImageThumbnailActualImage()

ILIAS\Filesystem\Util\ImageConversionTest::testImageThumbnailActualImage

(

)

Definition at line 54 of file ImageConversionTest.php.

                                                   : void
    {
        $img = __DIR__ . '/img/robot.jpg';
        $this->assertFileExists($img);
        $getimagesize = getimagesize($img);
        $original_width = $getimagesize[0]; // should be 600
        $original_height = $getimagesize[1]; // should be 800
        $this->assertSame(600, $original_width);
        $this->assertSame(800, $original_height);
 
        // make tumbnail
        $original_stream = Streams::ofResource(fopen($img, 'rb'));
 
        $thumbnail_converter = $this->images->thumbnail(
            $original_stream,
            100
        );
        $this->assertTrue($thumbnail_converter->isOK());
        $this->assertNotInstanceOf(\Throwable::class, $thumbnail_converter->getThrowableIfAny());
        $converted_stream = $thumbnail_converter->getStream();
 
        $getimagesizefromstring = getimagesizefromstring((string) $converted_stream);
 
        $this->assertSame(75, $getimagesizefromstring[0]); // width
        $this->assertSame(100, $getimagesizefromstring[1]); // height
    }

References ILIAS\Filesystem\Stream\Streams\ofResource().

Here is the call graph for this function:

testResizeByFixedSize()

ILIAS\Filesystem\Util\ImageConversionTest::testResizeByFixedSize	(	int	$width,
		int	$height,
		int	$final_width,
		int	$final_height,
		bool	$crop
	)

Definition at line 213 of file ImageConversionTest.php.

     : void {
        $stream = $this->createTestImageStream($width, $height);
        $dimensions = $this->getImageSizeFromStream($stream);
        $this->assertEquals($width, $dimensions[self::W]);
        $this->assertEquals($height, $dimensions[self::H]);
 
        $by_fixed = $this->images->resizeToFixedSize($stream, $final_width, $final_height, $crop);
        $this->assertTrue($by_fixed->isOK());
        $new_dimensions = $this->getImageSizeFromStream($by_fixed->getStream());
 
        $this->assertEquals($final_width, $new_dimensions[self::W]);
        $this->assertEquals($final_height, $new_dimensions[self::H]);
    }

testResizeToFitHeight()

ILIAS\Filesystem\Util\ImageConversionTest::testResizeToFitHeight	(	int	$width,
		int	$height,
		int	$final_height,
		int	$final_width
	)

Definition at line 164 of file ImageConversionTest.php.

     : void {
        $stream = $this->createTestImageStream($width, $height);
        $dimensions = $this->getImageSizeFromStream($stream);
        $this->assertEquals($width, $dimensions[self::W]);
        $this->assertEquals($height, $dimensions[self::H]);
 
        // resize to fit
        $resized = $this->images->resizeByHeight($stream, self::BY_HEIGHT_FINAL);
        $this->assertTrue($resized->isOK());
        $new_dimensions = $this->getImageSizeFromStream($resized->getStream());
 
        $this->assertEquals($final_width, $new_dimensions[self::W]);
        $this->assertEquals($final_height, $new_dimensions[self::H]);
 
        // check aspect ratio
        $this->assertSame(
            round($width > $height),
            round($final_width > $final_height)
        );
        $this->assertSame(
            round($width / $height),
            round($new_dimensions[self::W] / $new_dimensions[self::H])
        );
        $this->assertSame(
            $width > $height,
            $width > $height
        );
        $this->assertSame(
            $width > $height,
            $new_dimensions[self::W] > $new_dimensions[self::H]
        );
    }

testResizeToFitWidth()

ILIAS\Filesystem\Util\ImageConversionTest::testResizeToFitWidth	(	int	$width,
		int	$height,
		int	$final_width,
		int	$final_height
	)

Definition at line 116 of file ImageConversionTest.php.

     : void {
        $stream = $this->createTestImageStream($width, $height);
        $dimensions = $this->getImageSizeFromStream($stream);
        $this->assertEquals($width, $dimensions[self::W]);
        $this->assertEquals($height, $dimensions[self::H]);
 
        // resize to fit width
        $resized = $this->images->resizeByWidth($stream, self::BY_WIDTH_FINAL);
        $this->assertTrue($resized->isOK());
        $new_dimensions = $this->getImageSizeFromStream($resized->getStream());
 
        $this->assertEquals($final_width, $new_dimensions[self::W]);
        $this->assertEquals($final_height, $new_dimensions[self::H]);
 
        // check aspect ratio
        $this->assertSame(
            round($width > $height),
            round($final_width > $final_height)
        );
        $this->assertSame(
            round($width / $height),
            round($new_dimensions[self::W] / $new_dimensions[self::H])
        );
        $this->assertSame(
            $width > $height,
            $width > $height
        );
        $this->assertSame(
            $width > $height,
            $new_dimensions[self::W] > $new_dimensions[self::H]
        );
    }

testWriteImage()

ILIAS\Filesystem\Util\ImageConversionTest::testWriteImage

(

)

Definition at line 428 of file ImageConversionTest.php.

                                    : void
    {
        $img = $this->createTestImageStream(10, 10);
 
        $output_path = __DIR__ . '/img/output.jpg';
        $converter_options = (new ImageConversionOptions())
            ->withThrowOnError(true)
            ->withMakeTemporaryFiles(false)
            ->withFixedDimensions(100, 100)
            ->withOutputPath($output_path);
 
        $output_options = (new ImageOutputOptions())
            ->withQuality(10)
            ->withJpgOutput();
 
        $converter = new ImageConverter($converter_options, $output_options, $img);
        $this->assertTrue($converter->isOK());
 
        $this->assertFileExists($output_path);
        $stream = $converter->getStream();
        $this->assertEquals($output_path, $stream->getMetadata('uri'));
 
        unlink($output_path);
    }

testWrongFormats()

ILIAS\Filesystem\Util\ImageConversionTest::testWrongFormats

(

string

$format

)

Definition at line 302 of file ImageConversionTest.php.

                                                    : void
    {
        $options = new ImageOutputOptions();
        $this->expectException(\InvalidArgumentException::class);
        $wrong = $options->withFormat($format);
    }

References ILIAS\UI\Implementation\Component\Input\Field\$options.

testWrongQualities()

ILIAS\Filesystem\Util\ImageConversionTest::testWrongQualities

(

int

$quality

)

Definition at line 317 of file ImageConversionTest.php.

                                                    : void
    {
        $options = new ImageOutputOptions();
        $this->expectException(\InvalidArgumentException::class);
        $wrong = $options->withQuality($quality);
    }

References ILIAS\UI\Implementation\Component\Input\Field\$options.

Field Documentation

$images

Images ILIAS\Filesystem\Util\ImageConversionTest::$images

protected

Definition at line 44 of file ImageConversionTest.php.

BY_HEIGHT_FINAL

const ILIAS\Filesystem\Util\ImageConversionTest::BY_HEIGHT_FINAL = 756

protected

Definition at line 38 of file ImageConversionTest.php.

BY_WIDTH_FINAL

const ILIAS\Filesystem\Util\ImageConversionTest::BY_WIDTH_FINAL = 256

protected

Definition at line 37 of file ImageConversionTest.php.

Referenced by ILIAS\Filesystem\Util\ImageConversionTest\getImageSizesByWidth().

H

const ILIAS\Filesystem\Util\ImageConversionTest::H = 'height'

protected

Definition at line 40 of file ImageConversionTest.php.

IMAGE_JPEG

const ILIAS\Filesystem\Util\ImageConversionTest::IMAGE_JPEG = 'image/jpeg'

protected

Definition at line 41 of file ImageConversionTest.php.

IMAGE_PNG

const ILIAS\Filesystem\Util\ImageConversionTest::IMAGE_PNG = 'image/png'

protected

Definition at line 42 of file ImageConversionTest.php.

IMAGE_WEBP

const ILIAS\Filesystem\Util\ImageConversionTest::IMAGE_WEBP = 'image/webp'

protected

Definition at line 43 of file ImageConversionTest.php.

W

const ILIAS\Filesystem\Util\ImageConversionTest::W = 'width'

protected

Definition at line 39 of file ImageConversionTest.php.

---

The documentation for this class was generated from the following file:

• components/ILIAS/Filesystem/tests/Util/Convert/ImageConversionTest.php