create-berna-stencil 1.0.23 → 1.0.25

package/src/api/core/vendor/fakerphp/faker/test/Faker/Provider/BiasedTest.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace Faker\Test\Provider;
+
+use Faker\Provider\Biased;
+use Faker\Test\TestCase;
+
+/**
+ * @group legacy
+ */
+final class BiasedTest extends TestCase
+{
+    public const MAX = 10;
+    public const NUMBERS = 25000;
+    protected $results = [];
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->results = array_fill(1, self::MAX, 0);
+    }
+
+    public function performFake($function): void
+    {
+        for ($i = 0; $i < self::NUMBERS; ++$i) {
+            ++$this->results[$this->faker->biasedNumberBetween(1, self::MAX, $function)];
+        }
+    }
+
+    public function testUnbiased(): void
+    {
+        $this->performFake(['\Faker\Provider\Biased', 'unbiased']);
+
+        // assert that all numbers are near the expected unbiased value
+        foreach ($this->results as $number => $amount) {
+            // integral
+            $assumed = (1 / self::MAX * $number) - (1 / self::MAX * ($number - 1));
+            // calculate the fraction of the whole area
+            $assumed /= 1;
+            self::assertGreaterThan(self::NUMBERS * $assumed * .95, $amount, 'Value was more than 5 percent under the expected value');
+            self::assertLessThan(self::NUMBERS * $assumed * 1.05, $amount, 'Value was more than 5 percent over the expected value');
+        }
+    }
+
+    /**
+     * @requires PHP < 8.3
+     */
+    public function testLinearHigh(): void
+    {
+        $this->performFake(['\Faker\Provider\Biased', 'linearHigh']);
+
+        foreach ($this->results as $number => $amount) {
+            // integral
+            $assumed = 0.5 * (1 / self::MAX * $number) ** 2 - 0.5 * (1 / self::MAX * ($number - 1)) ** 2;
+            // calculate the fraction of the whole area
+            $assumed /= 1 ** 2 * .5;
+            self::assertGreaterThan(self::NUMBERS * $assumed * .9, $amount, 'Value was more than 10 percent under the expected value');
+            self::assertLessThan(self::NUMBERS * $assumed * 1.1, $amount, 'Value was more than 10 percent over the expected value');
+        }
+    }
+
+    public function testLinearLow(): void
+    {
+        $this->performFake(['\Faker\Provider\Biased', 'linearLow']);
+
+        foreach ($this->results as $number => $amount) {
+            // integral
+            $assumed = -0.5 * (1 / self::MAX * $number) ** 2 - -0.5 * (1 / self::MAX * ($number - 1)) ** 2;
+            // shift the graph up
+            $assumed += 1 / self::MAX;
+            // calculate the fraction of the whole area
+            $assumed /= 1 ** 2 * .5;
+            self::assertGreaterThan(self::NUMBERS * $assumed * .9, $amount, 'Value was more than 10 percent under the expected value');
+            self::assertLessThan(self::NUMBERS * $assumed * 1.1, $amount, 'Value was more than 10 percent over the expected value');
+        }
+    }
+
+    protected function getProviders(): iterable
+    {
+        yield new Biased($this->faker);
+    }
+}

package/src/api/core/vendor/fakerphp/faker/test/Faker/Provider/ColorTest.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Faker\Test\Provider;
+
+use Faker\Provider\Color;
+use Faker\Test\TestCase;
+
+/**
+ * @group legacy
+ */
+final class ColorTest extends TestCase
+{
+    public function testHexColor(): void
+    {
+        self::assertMatchesRegularExpression('/^#[a-f0-9]{6}$/i', Color::hexColor());
+    }
+
+    public function testSafeHexColor(): void
+    {
+        self::assertMatchesRegularExpression('/^#[a-f0-9]{6}$/i', Color::safeHexColor());
+    }
+
+    public function testRgbColorAsArray(): void
+    {
+        self::assertCount(3, Color::rgbColorAsArray());
+    }
+
+    public function testRgbColor(): void
+    {
+        $regexp = '([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])';
+        self::assertMatchesRegularExpression('/^' . $regexp . ',' . $regexp . ',' . $regexp . '$/i', Color::rgbColor());
+    }
+
+    public function testRgbCssColor(): void
+    {
+        $regexp = '([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])';
+        self::assertMatchesRegularExpression('/^rgb\(' . $regexp . ',' . $regexp . ',' . $regexp . '\)$/i', Color::rgbCssColor());
+    }
+
+    public function testRgbaCssColor(): void
+    {
+        $regexp = '([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])';
+        $regexpAlpha = '([01]?(\.\d+)?)';
+        self::assertMatchesRegularExpression('/^rgba\(' . $regexp . ',' . $regexp . ',' . $regexp . ',' . $regexpAlpha . '\)$/i', Color::rgbaCssColor());
+    }
+
+    public function testSafeColorName(): void
+    {
+        self::assertMatchesRegularExpression('/^[\w]+$/', Color::safeColorName());
+    }
+
+    public function testColorName(): void
+    {
+        self::assertMatchesRegularExpression('/^[\w]+$/', Color::colorName());
+    }
+
+    public function testHslColor(): void
+    {
+        $regexp360 = '(?:36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])';
+        $regexp100 = '(?:100|[1-9]?[0-9])';
+        self::assertMatchesRegularExpression('/^' . $regexp360 . ',' . $regexp100 . ',' . $regexp100 . '$/', Color::hslColor());
+    }
+
+    public function testHslColorArray(): void
+    {
+        self::assertCount(3, Color::hslColorAsArray());
+    }
+}

package/src/api/core/vendor/fakerphp/faker/test/Faker/Provider/CompanyTest.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Faker\Test\Provider;
+
+use Faker\Provider\Company;
+use Faker\Provider\Lorem;
+use Faker\Test\TestCase;
+
+/**
+ * @group legacy
+ */
+final class CompanyTest extends TestCase
+{
+    public function testJobTitle(): void
+    {
+        $jobTitle = $this->faker->jobTitle();
+        $pattern = '/^[A-Za-z]+$/';
+        self::assertMatchesRegularExpression($pattern, $jobTitle);
+    }
+
+    protected function getProviders(): iterable
+    {
+        yield new Company($this->faker);
+
+        yield new Lorem($this->faker);
+    }
+}

package/src/api/core/vendor/fakerphp/faker/test/Faker/Provider/DateTimeTest.php

@@ -0,0 +1,295 @@
+<?php
+
+namespace Faker\Test\Provider;
+
+use Faker\Provider\DateTime as DateTimeProvider;
+use Faker\Test\TestCase;
+
+/**
+ * @group legacy
+ */
+final class DateTimeTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        $this->defaultTz = 'UTC';
+        DateTimeProvider::setDefaultTimezone($this->defaultTz);
+    }
+
+    protected function tearDown(): void
+    {
+        DateTimeProvider::setDefaultTimezone();
+    }
+
+    public function testPreferDefaultTimezoneOverSystemTimezone(): void
+    {
+        /**
+         * Set the system timezone to something *other* than the timezone used
+         * in setUp().
+         */
+        $originalSystemTimezone = date_default_timezone_get();
+        $systemTimezone = 'Antarctica/Vostok';
+        date_default_timezone_set($systemTimezone);
+
+        /**
+         * Get a new date/time value and assert that it prefers the default
+         * timezone over the system timezone.
+         */
+        $date = DateTimeProvider::dateTime();
+        self::assertNotSame($systemTimezone, $date->getTimezone()->getName());
+        self::assertSame($this->defaultTz, $date->getTimezone()->getName());
+
+        /**
+         * Restore the system timezone.
+         */
+        date_default_timezone_set($originalSystemTimezone);
+    }
+
+    public function testUseSystemTimezoneWhenDefaultTimezoneIsNotSet(): void
+    {
+        /**
+         * Set the system timezone to something *other* than the timezone used
+         * in setUp() *and* reset the default timezone.
+         */
+        $originalSystemTimezone = date_default_timezone_get();
+        $originalDefaultTimezone = DateTimeProvider::getDefaultTimezone();
+        $systemTimezone = 'Antarctica/Vostok';
+        date_default_timezone_set($systemTimezone);
+        DateTimeProvider::setDefaultTimezone();
+
+        /**
+         * Get a new date/time value and assert that it uses the system timezone
+         * and not the system timezone.
+         */
+        $date = DateTimeProvider::dateTime();
+        self::assertSame($systemTimezone, $date->getTimezone()->getName());
+        self::assertNotSame($this->defaultTz, $date->getTimezone()->getName());
+
+        /**
+         * Restore the system timezone.
+         */
+        date_default_timezone_set($originalSystemTimezone);
+    }
+
+    public function testUnixTime(): void
+    {
+        $timestamp = DateTimeProvider::unixTime();
+        self::assertIsInt($timestamp);
+        self::assertGreaterThanOrEqual(0, $timestamp);
+        self::assertLessThanOrEqual(time(), $timestamp);
+    }
+
+    public function testDateTime(): void
+    {
+        $date = DateTimeProvider::dateTime();
+        self::assertInstanceOf('\DateTime', $date);
+        self::assertGreaterThanOrEqual(new \DateTime('@0'), $date);
+        self::assertLessThanOrEqual(new \DateTime(), $date);
+        self::assertEquals(new \DateTimeZone($this->defaultTz), $date->getTimezone());
+    }
+
+    public function testDateTimeWithTimezone(): void
+    {
+        $date = DateTimeProvider::dateTime('now', 'America/New_York');
+        self::assertEquals($date->getTimezone(), new \DateTimeZone('America/New_York'));
+    }
+
+    public function testDateTimeAD(): void
+    {
+        $date = DateTimeProvider::dateTimeAD();
+        self::assertInstanceOf('\DateTime', $date);
+        self::assertGreaterThanOrEqual(new \DateTime('0000-01-01 00:00:00'), $date);
+        self::assertLessThanOrEqual(new \DateTime(), $date);
+        self::assertEquals(new \DateTimeZone($this->defaultTz), $date->getTimezone());
+    }
+
+    public function testDateTimeThisCentury(): void
+    {
+        $date = DateTimeProvider::dateTimeThisCentury();
+        self::assertInstanceOf('\DateTime', $date);
+        self::assertGreaterThanOrEqual(new \DateTime('-100 year'), $date);
+        self::assertLessThanOrEqual(new \DateTime(), $date);
+        self::assertEquals(new \DateTimeZone($this->defaultTz), $date->getTimezone());
+    }
+
+    public function testDateTimeThisDecade(): void
+    {
+        $date = DateTimeProvider::dateTimeThisDecade();
+        self::assertInstanceOf('\DateTime', $date);
+        self::assertGreaterThanOrEqual(new \DateTime('-10 year'), $date);
+        self::assertLessThanOrEqual(new \DateTime(), $date);
+        self::assertEquals(new \DateTimeZone($this->defaultTz), $date->getTimezone());
+    }
+
+    public function testDateTimeThisYear(): void
+    {
+        $date = DateTimeProvider::dateTimeThisYear();
+        self::assertInstanceOf('\DateTime', $date);
+        self::assertGreaterThanOrEqual(new \DateTime('first day of january this year'), $date);
+        self::assertLessThanOrEqual(new \DateTime(), $date);
+        self::assertEquals(new \DateTimeZone($this->defaultTz), $date->getTimezone());
+    }
+
+    public function testDateTimeThisMonth(): void
+    {
+        $date = DateTimeProvider::dateTimeThisMonth();
+        self::assertInstanceOf('\DateTime', $date);
+        self::assertGreaterThanOrEqual(new \DateTime('-1 month'), $date);
+        self::assertLessThanOrEqual(new \DateTime(), $date);
+        self::assertEquals(new \DateTimeZone($this->defaultTz), $date->getTimezone());
+    }
+
+    public function testDateTimeThisCenturyWithTimezone(): void
+    {
+        $date = DateTimeProvider::dateTimeThisCentury('now', 'America/New_York');
+        self::assertEquals($date->getTimezone(), new \DateTimeZone('America/New_York'));
+    }
+
+    public function testDateTimeThisDecadeWithTimezone(): void
+    {
+        $date = DateTimeProvider::dateTimeThisDecade('now', 'America/New_York');
+        self::assertEquals($date->getTimezone(), new \DateTimeZone('America/New_York'));
+    }
+
+    public function testDateTimeThisYearWithTimezone(): void
+    {
+        $date = DateTimeProvider::dateTimeThisYear('now', 'America/New_York');
+        self::assertEquals($date->getTimezone(), new \DateTimeZone('America/New_York'));
+    }
+
+    public function testDateTimeThisMonthWithTimezone(): void
+    {
+        $date = DateTimeProvider::dateTimeThisMonth('now', 'America/New_York');
+        self::assertEquals($date->getTimezone(), new \DateTimeZone('America/New_York'));
+    }
+
+    public function testIso8601(): void
+    {
+        $date = DateTimeProvider::iso8601();
+        self::assertMatchesRegularExpression('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[+-Z](\d{4})?$/', $date);
+        self::assertGreaterThanOrEqual(new \DateTime('@0'), new \DateTime($date));
+        self::assertLessThanOrEqual(new \DateTime(), new \DateTime($date));
+    }
+
+    public function testDate(): void
+    {
+        $date = DateTimeProvider::date();
+        self::assertMatchesRegularExpression('/^\d{4}-\d{2}-\d{2}$/', $date);
+        self::assertGreaterThanOrEqual(new \DateTime('@0'), new \DateTime($date));
+        self::assertLessThanOrEqual(new \DateTime(), new \DateTime($date));
+    }
+
+    public function testTime(): void
+    {
+        $date = DateTimeProvider::time();
+        self::assertMatchesRegularExpression('/^\d{2}:\d{2}:\d{2}$/', $date);
+    }
+
+    /**
+     * @dataProvider providerDateTimeBetween
+     */
+    public function testDateTimeBetween($start, $end): void
+    {
+        $date = DateTimeProvider::dateTimeBetween($start, $end);
+        self::assertInstanceOf('\DateTime', $date);
+        self::assertGreaterThanOrEqual(new \DateTime($start), $date);
+        self::assertLessThanOrEqual(new \DateTime($end ?: 'now'), $date);
+        self::assertEquals(new \DateTimeZone($this->defaultTz), $date->getTimezone());
+    }
+
+    public function providerDateTimeBetween()
+    {
+        return [
+            ['-1 year', false],
+            ['-1 year', null],
+            ['-1 day', '-1 hour'],
+            ['-1 day', 'now'],
+        ];
+    }
+
+    /**
+     * @dataProvider providerDateTimeInInterval
+     */
+    public function testDateTimeInInterval($start, $interval, $isInFuture): void
+    {
+        $date = DateTimeProvider::dateTimeInInterval($start, $interval);
+        self::assertInstanceOf('\DateTime', $date);
+
+        $_interval = \DateInterval::createFromDateString($interval);
+        $_start = new \DateTime($start);
+
+        if ($isInFuture) {
+            self::assertGreaterThanOrEqual($_start, $date);
+            self::assertLessThanOrEqual($_start->add($_interval), $date);
+        } else {
+            self::assertLessThanOrEqual($_start, $date);
+            self::assertGreaterThanOrEqual($_start->add($_interval), $date);
+        }
+    }
+
+    public function providerDateTimeInInterval()
+    {
+        return [
+            ['-1 year', '+5 days', true],
+            ['-1 day', '-1 hour', false],
+            ['-1 day', '+1 hour', true],
+        ];
+    }
+
+    public function testFixedSeedWithMaximumTimestamp(): void
+    {
+        $max = '2118-03-01 12:00:00';
+
+        mt_srand(1);
+        $unixTime = DateTimeProvider::unixTime($max);
+        $datetimeAD = DateTimeProvider::dateTimeAD($max);
+        $dateTime1 = DateTimeProvider::dateTime($max);
+        $dateTimeBetween = DateTimeProvider::dateTimeBetween('2014-03-01 06:00:00', $max);
+        $date = DateTimeProvider::date('Y-m-d', $max);
+        $time = DateTimeProvider::time('H:i:s', $max);
+        $iso8601 = DateTimeProvider::iso8601($max);
+        $dateTimeThisCentury = DateTimeProvider::dateTimeThisCentury($max);
+        $dateTimeThisDecade = DateTimeProvider::dateTimeThisDecade($max);
+        $dateTimeThisMonth = DateTimeProvider::dateTimeThisMonth($max);
+        $amPm = DateTimeProvider::amPm($max);
+        $dayOfMonth = DateTimeProvider::dayOfMonth($max);
+        $dayOfWeek = DateTimeProvider::dayOfWeek($max);
+        $month = DateTimeProvider::month($max);
+        $monthName = DateTimeProvider::monthName($max);
+        $year = DateTimeProvider::year($max);
+        $dateTimeThisYear = DateTimeProvider::dateTimeThisYear($max);
+        mt_srand();
+
+        //regenerate Random Date with same seed and same maximum end timestamp
+        mt_srand(1);
+        self::assertEquals($unixTime, DateTimeProvider::unixTime($max));
+        self::assertEquals($datetimeAD, DateTimeProvider::dateTimeAD($max));
+        self::assertEquals($dateTime1, DateTimeProvider::dateTime($max));
+        self::assertEquals($dateTimeBetween, DateTimeProvider::dateTimeBetween('2014-03-01 06:00:00', $max));
+        self::assertEquals($date, DateTimeProvider::date('Y-m-d', $max));
+        self::assertEquals($time, DateTimeProvider::time('H:i:s', $max));
+        self::assertEquals($iso8601, DateTimeProvider::iso8601($max));
+        self::assertEquals($dateTimeThisCentury, DateTimeProvider::dateTimeThisCentury($max));
+        self::assertEquals($dateTimeThisDecade, DateTimeProvider::dateTimeThisDecade($max));
+        self::assertEquals($dateTimeThisMonth, DateTimeProvider::dateTimeThisMonth($max));
+        self::assertEquals($amPm, DateTimeProvider::amPm($max));
+        self::assertEquals($dayOfMonth, DateTimeProvider::dayOfMonth($max));
+        self::assertEquals($dayOfWeek, DateTimeProvider::dayOfWeek($max));
+        self::assertEquals($month, DateTimeProvider::month($max));
+        self::assertEquals($monthName, DateTimeProvider::monthName($max));
+        self::assertEquals($year, DateTimeProvider::year($max));
+        self::assertEquals($dateTimeThisYear, DateTimeProvider::dateTimeThisYear($max));
+        mt_srand();
+    }
+
+    public function testTimezone(): void
+    {
+        $timezone = DateTimeProvider::timezone();
+        $countryTimezone = DateTimeProvider::timezone('US');
+
+        self::assertIsString($timezone);
+        self::assertContains($timezone, \DateTimeZone::listIdentifiers());
+        self::assertIsString($countryTimezone);
+        self::assertContains($countryTimezone, \DateTimeZone::listIdentifiers(\DateTimeZone::PER_COUNTRY, 'US'));
+    }
+}

package/src/api/core/vendor/fakerphp/faker/test/Faker/Provider/HtmlLoremTest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Faker\Test\Provider;
+
+use Faker\Provider\HtmlLorem;
+use Faker\Test\TestCase;
+
+/**
+ * @group legacy
+ */
+final class HtmlLoremTest extends TestCase
+{
+    public function testProvider(): void
+    {
+        $node = $this->faker->randomHtml(6, 10);
+        self::assertStringStartsWith('<html>', $node);
+        self::assertStringEndsWith("</html>\n", $node);
+    }
+
+    public function testRandomHtmlReturnsValidHTMLString(): void
+    {
+        $node = $this->faker->randomHtml(6, 10);
+        $dom = new \DOMDocument();
+        $error = $dom->loadHTML($node);
+        self::assertTrue($error);
+    }
+
+    protected function getProviders(): iterable
+    {
+        yield new HtmlLorem($this->faker);
+    }
+}

package/src/api/core/vendor/fakerphp/faker/test/Faker/Provider/ImageTest.php

@@ -0,0 +1,192 @@
+<?php
+
+namespace Faker\Test\Provider;
+
+use Faker\Provider\Image;
+use Faker\Test\TestCase;
+
+/**
+ * @group legacy
+ */
+final class ImageTest extends TestCase
+{
+    public function testImageUrlUses640x680AsTheDefaultSize(): void
+    {
+        self::assertMatchesRegularExpression(
+            '#^https://via.placeholder.com/640x480.png/#',
+            Image::imageUrl(),
+        );
+    }
+
+    public function testImageUrlAcceptsCustomWidthAndHeight(): void
+    {
+        self::assertMatchesRegularExpression(
+            '#^https://via.placeholder.com/800x400.png/#',
+            Image::imageUrl(800, 400),
+        );
+    }
+
+    public function testImageUrlAcceptsCustomCategory(): void
+    {
+        self::assertMatchesRegularExpression(
+            '#^https://via.placeholder.com/800x400.png/[\w]{6}\?text=nature\+.*#',
+            Image::imageUrl(800, 400, 'nature'),
+        );
+    }
+
+    public function testImageUrlAcceptsCustomText(): void
+    {
+        self::assertMatchesRegularExpression(
+            '#^https://via.placeholder.com/800x400.png/[\w]{6}\?text=nature\+Faker#',
+            Image::imageUrl(800, 400, 'nature', false, 'Faker'),
+        );
+    }
+
+    public function testImageUrlReturnsLinkToRegularImageWhenGrayIsFalse(): void
+    {
+        $imageUrl = Image::imageUrl(
+            800,
+            400,
+            'nature',
+            false,
+            'Faker',
+            false,
+        );
+
+        self::assertMatchesRegularExpression(
+            '#^https://via.placeholder.com/800x400.png/[\w]{6}\?text=nature\+Faker#',
+            $imageUrl,
+        );
+    }
+
+    public function testImageUrlReturnsLinkToRegularImageWhenGrayIsTrue(): void
+    {
+        $imageUrl = Image::imageUrl(
+            800,
+            400,
+            'nature',
+            false,
+            'Faker',
+            true,
+        );
+
+        self::assertMatchesRegularExpression(
+            '#^https://via.placeholder.com/800x400.png/CCCCCC\?text=nature\+Faker#',
+            $imageUrl,
+        );
+    }
+
+    public function testImageUrlAddsARandomGetParameterByDefault(): void
+    {
+        $url = Image::imageUrl(800, 400);
+        $splitUrl = preg_split('/\?text=/', $url);
+
+        self::assertEquals(count($splitUrl), 2);
+        self::assertMatchesRegularExpression('#\w*#', $splitUrl[1]);
+    }
+
+    public function testImageUrlThrowsExceptionOnInvalidImageFormat(): void
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        Image::imageUrl(
+            800,
+            400,
+            'nature',
+            false,
+            'Faker',
+            true,
+            'foo',
+        );
+    }
+
+    public function testImageUrlAcceptsDifferentImageFormats(): void
+    {
+        foreach (Image::getFormats() as $format) {
+            $imageUrl = Image::imageUrl(
+                800,
+                400,
+                'nature',
+                false,
+                'Faker',
+                true,
+                $format,
+            );
+
+            self::assertMatchesRegularExpression(
+                "#^https://via.placeholder.com/800x400.{$format}/CCCCCC\?text=nature\+Faker#",
+                $imageUrl,
+            );
+        }
+    }
+
+    public function testDownloadWithDefaults(): void
+    {
+        self::checkUrlConnection(Image::BASE_URL);
+
+        $file = Image::image(sys_get_temp_dir());
+        self::assertFileExists($file);
+
+        self::checkImageProperties($file, 640, 480, 'png');
+    }
+
+    public function testDownloadWithDifferentImageFormats(): void
+    {
+        self::checkUrlConnection(Image::BASE_URL);
+
+        foreach (Image::getFormats() as $format) {
+            $width = 800;
+            $height = 400;
+            $file = Image::image(
+                sys_get_temp_dir(),
+                $width,
+                $height,
+                'nature',
+                true,
+                false,
+                'Faker',
+                true,
+                $format,
+            );
+            self::assertFileExists($file);
+
+            self::checkImageProperties($file, $width, $height, $format);
+        }
+    }
+
+    private static function checkImageProperties(
+        string $file,
+        int $width,
+        int $height,
+        string $format
+    ): void {
+        if (function_exists('getimagesize')) {
+            $imageConstants = Image::getFormatConstants();
+            [$actualWidth, $actualHeight, $type, $attr] = getimagesize($file);
+            self::assertEquals($width, $actualWidth);
+            self::assertEquals($height, $actualHeight);
+            self::assertEquals($imageConstants[$format], $type);
+        } else {
+            self::assertEquals($format, pathinfo($file, PATHINFO_EXTENSION));
+        }
+
+        if (file_exists($file)) {
+            unlink($file);
+        }
+    }
+
+    private static function checkUrlConnection(string $url): void
+    {
+        $curlPing = curl_init($url);
+        curl_setopt($curlPing, CURLOPT_TIMEOUT, 5);
+        curl_setopt($curlPing, CURLOPT_CONNECTTIMEOUT, 5);
+        curl_setopt($curlPing, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($curlPing, CURLOPT_FOLLOWLOCATION, true);
+        $data = curl_exec($curlPing);
+        $httpCode = curl_getinfo($curlPing, CURLINFO_HTTP_CODE);
+        curl_close($curlPing);
+
+        if ($httpCode < 200 || $httpCode > 300) {
+            self::markTestSkipped(sprintf('"%s" is offline, skipping test', $url));
+        }
+    }
+}