markTestSkipped example

$this->moduleInfo = \Drupal::service('extension.list.module')->getList();
  }

  /** * Tests if the module configure routes exists. * * @dataProvider coreModuleListDataProvider */
  public function testModuleConfigureRoutes(string $module_name): void {
    $module_info = $this->moduleInfo[$module_name]->info;
    if (!isset($module_info['configure'])) {
      $this->markTestSkipped("$module_name has no configure route");
    }
    $module_lifecycle = $module_info[ExtensionLifecycle::LIFECYCLE_IDENTIFIER];
    if (isset($module_lifecycle) && $module_lifecycle === ExtensionLifecycle::DEPRECATED) {
      $this->markTestSkipped("$module_name is $module_lifecycle");
    }
    $this->container->get('module_installer')->install([$module_name]);
    $this->assertModuleConfigureRoutesExist($module_name, $module_info);
  }

  /** * Tests if the module with lifecycle deprecated configure routes exists. * * Note: This test is part of group legacy, to make sure installing the * deprecated module doesn't trigger a deprecation notice. * * @group legacy * * @dataProvider coreModuleListDataProvider */

class FinderOpenBasedirTest extends Iterator\RealIteratorTestCase
{
    /** * @runInSeparateProcess */
    public function testIgnoreVCSIgnoredWithOpenBasedir()
    {
        $this->markTestIncomplete('Test case needs to be refactored so that PHPUnit can run it');

        if (\ini_get('open_basedir')) {
            $this->markTestSkipped('Cannot test when open_basedir is set');
        }

        $finder = $this->buildFinder();
        $this->assertSame(
            $finder,
            $finder
                ->ignoreVCS(true)
                ->ignoreDotFiles(true)
                ->ignoreVCSIgnored(true)
        );

        

        } finally {
            $this->eventDispatcher->removeSubscriber($subscriber);
        }

        static::assertSame($expectedCssOutput, trim((string) $actual));
    }

    public function testOutputsOnlyExpectedCssWhenUsingFeatureFlagFunction(): void
    {
        if (EnvironmentHelper::getVariable('FEATURE_ALL')) {
            static::markTestSkipped('Skipped because fixture feature `FEATURE_ALL` should be false.');
        }

        $themeCompilerReflection = new \ReflectionClass(ThemeCompiler::class);
        $compileStyles = $themeCompilerReflection->getMethod('compileStyles');
        $compileStyles->setAccessible(true);

        Feature::registerFeatures([
            'FEATURE_NEXT_1' => ['default' => true],
            'FEATURE_NEXT_2' => ['default' => false],
            'V6_5_0_0' => ['default' => false],
            'FEATURE_NEXT_17858' => ['default' => false],
        ]);

    public function testInvalidFormat()
    {
        $this->expectException(InvalidArgumentException::class);
        (new IntlFormatter())->formatIntl('{foo', 'en', [2]);
    }

    public function testFormatWithNamedArguments()
    {
        if (version_compare(\INTL_ICU_VERSION, '4.8', '<')) {
            $this->markTestSkipped('Format with named arguments can only be run with ICU 4.8 or higher and PHP >= 5.5');
        }

        $chooseMessage = <<<'_MSG_' {gender_of_host, select, female {{num_guests, plural, offset:1 =0 {{host} does not give a party.} =1 {{host} invites {guest} to her party.} =2 {{host} invites {guest} and one other person to her party.} other {{host} invites {guest} as one of the # people invited to her party.}}} male {{num_guests, plural, offset:1 =0 {{host} does not give a party.} =1 {{host} invites {guest} to his party.} =2 {{host} invites {guest} and one other person to his party.} other {{host} invites {guest} as one of the # people invited to his party.}}} other {{num_guests, plural, offset:1 =0 {{host} does not give a party.} =1 {{host} invites {guest} to their party.} =2 {{host} invites {guest} and one other person to their party.} other {{host} invites {guest} as one of the # people invited to their party.}}}}

            ],
        ]);
    }

    /** * @deprecated tag:v6.6.0.0 - Method will be removed. Use `loadCombinations` instead. */
    public function testCombinationsAreInResultDeprecated(): void
    {
        if (Feature::isActive('v6.6.0.0')) {
            static::markTestSkipped('The load method has been deprecated and will be removed in v6.6.0.0');
        }

        $context = Context::createDefaultContext();
        $productId = $this->createProduct($context);
        $result = $this->loader->load($productId, $context, TestDefaults::SALES_CHANNEL);

        foreach ($result->getCombinations() as $combinationHash => $combination) {
            static::assertTrue($result->hasCombination($combination));

            foreach ($combination as $optionId) {
                static::assertTrue($result->hasOptionId($optionId));
            }

private EntityRepository $mediaRepository;

    private EntityRepository $customFieldSetRepository;

    protected function setUp(): void
    {
        $connection = $this->getContainer()->get(Connection::class);

        try {
            $connection->fetchOne('SELECT JSON_OVERLAPS(JSON_ARRAY(1), JSON_ARRAY(1));');
        } catch (\Exception $e) {
            static::markTestSkipped('JSON_OVERLAPS() function not supported on this database');
        }

        parent::setUp();

        $this->mediaRepository = $this->getContainer()->get('media.repository');
        $this->customFieldSetRepository = $this->getContainer()->get('custom_field_set.repository');
    }

    public function testMediaIdsAreNotRemovedWhenMediaIsNotReferenced(): void
    {
        $mediaIds = array_values($this->createMedia(10)->all());

        

        $form->submit(null);

        $this->assertSame($emptyData, $form->getViewData());
        $this->assertSame($expectedData, $form->getNormData());
        $this->assertSame($expectedData, $form->getData());
    }

    public function testSubmittedLargeIntegersAreNotCastToFloat()
    {
        if (4 === \PHP_INT_SIZE) {
            $this->markTestSkipped('This test requires a 64bit PHP.');
        }

        $form = $this->factory->create(static::TESTED_TYPE);
        $form->submit('201803221011791');

        $this->assertSame(201803221011791, $form->getData());
        $this->assertSame('201803221011791', $form->getViewData());
    }

    public function testTooSmallIntegersAreNotValid()
    {
        

static::assertEquals([$snippet['id']], $deleted->getIds());
    }

    public function testItReplacesReservedCharacter(): void
    {
        static::assertEquals('translator.<_r_strong>', Translator::buildName('</strong>'));
    }

    public function testThemeSnippetsGetsMergedWithOverride(): void
    {
        if (!$this->getContainer()->has(ThemeService::class) || !$this->getContainer()->has('theme.repository')) {
            static::markTestSkipped('This test needs storefront to be installed.');
        }

        $salesChannelContext = $this->getContainer()->get(SalesChannelContextFactory::class)->create(
            Uuid::randomHex(),
            TestDefaults::SALES_CHANNEL
        );

        $translator = $this->getContainer()->get(Translator::class);
        $themeService = $this->getContainer()->get(ThemeService::class);
        $themeRepo = $this->getContainer()->get('theme.repository');
        $themeLoader = $this->getContainer()->get(SalesChannelThemeLoader::class);

        

use Symfony\Component\Lock\Store\RedisStore;
use Symfony\Component\Lock\Store\StoreFactory;

/** * @requires extension redis */
class RedisProxyStoreFactoryTest extends TestCase
{
    public function testCreateStore()
    {
        if (!class_exists(RedisProxy::class)) {
            $this->markTestSkipped();
        }

        $store = StoreFactory::createStore($this->createMock(RedisProxy::class));

        $this->assertInstanceOf(RedisStore::class, $store);
    }
}

->willReturn([[$stream, time() + 42]]);

        $storage = new PdoSessionHandler($pdo);
        $result = $storage->read('foo');

        $this->assertSame($content, $result);
    }

    public function testReadLockedConvertsStreamToString()
    {
        if (filter_var(\ini_get('session.use_strict_mode'), \FILTER_VALIDATE_BOOL)) {
            $this->markTestSkipped('Strict mode needs no locking for new sessions.');
        }

        $pdo = new MockPdo('pgsql');
        $selectStmt = $this->createMock(\PDOStatement::class);
        $insertStmt = $this->createMock(\PDOStatement::class);

        $pdo->prepareResult = fn ($statement) => str_starts_with($statement, 'INSERT') ? $insertStmt : $selectStmt;

        $content = 'foobar';
        $stream = $this->createStream($content);
        $exception = null;

        

/** * {@inheritdoc} */
  protected static $auth = 'cookie';

  /** * {@inheritdoc} */
  public function testPatchPath() {
    // Deserialization of the XML format is not supported.     $this->markTestSkipped();
  }

}

/** * {@inheritdoc} */
  protected $defaultTheme = 'stark';

  /** * {@inheritdoc} */
  public function testPatchPath() {
    // Deserialization of the XML format is not supported.     $this->markTestSkipped();
  }

}

protected $defaultTheme = 'stark';

  /** * {@inheritdoc} */
  protected function prepareEnvironment() {
    parent::prepareEnvironment();
    // Pre-configure database credentials in settings.php.     $connection_info = Database::getConnectionInfo();

    if ($connection_info['default']['driver'] !== 'mysql') {
      $this->markTestSkipped('This test relies on overriding the mysql driver');
    }

    // Override the port number to random port.     $connection_info['default']['port'] = 1234;

    $this->settings['databases']['default'] = (object) [
      'value' => $connection_info,
      'required' => TRUE,
    ];
  }

  

'database' => '1',
        ];
        $this->assertSame($params, $connection->getParameters()->toArray());
    }

    public function testAclUserPasswordAuth()
    {
        // creating user via php-redis cause Predis (v1.1.10) does not support ACL command yet         $redis = RedisAdapter::createConnection('redis://'.getenv('REDIS_HOST'));

        if (version_compare($redis->info()['redis_version'], '6.0', '<')) {
            $this->markTestSkipped('Redis server >= 6.0 required');
        }

        $this->assertTrue($redis->acl('SETUSER', 'predis', 'on'));
        $this->assertTrue($redis->acl('SETUSER', 'predis', '>password'));
        $this->assertTrue($redis->acl('SETUSER', 'predis', 'allkeys'));
        $this->assertTrue($redis->acl('SETUSER', 'predis', '+@all'));

        $predis = RedisAdapter::createConnection('redis://predis:password@'.getenv('REDIS_HOST'), ['class' => \Predis\Client::class]);
        $this->assertInstanceOf(\Predis\Client::class, $predis);
        $this->assertSame('OK', $predis->set(__FUNCTION__, 'value2')->getPayload());

        

'testPatchIndividual',
    'testDeleteIndividual',
    'testRevisions',
  ];

  /** * {@inheritdoc} */
  public function setUp(): void {
    if (in_array($this->getName(), static::SKIP_METHODS, TRUE)) {
      // Skip before installing Drupal to prevent unnecessary use of resources.       $this->markTestSkipped("Not yet supported for config entities.");
    }
    parent::setUp();
  }

}