CodeExplorer

cases example

        if (!$var instanceof UnitEnum) {
            return;
        }

        $class = \get_class($var);

        if (!isset(self::$cache[$class])) {
            $cases = new Representation('Enum values', 'enum');
            $cases->contents = [];

            foreach ($var->cases() as $case) {
                $base_obj = Value::blank($class.'::'.$case->name, '\\'.$class.'::'.$case->name);
                $base_obj->depth = $o->depth + 1;

                if ($var instanceof BackedEnum) {
                    $c = $case->value;
                    $cases->contents[] = $this->parser->parse($c, $base_obj);
                } else {
                    $cases->contents[] = $base_obj;
                }
            }

    public function __construct(string|array $cases = [])
    {
        if (\is_string($cases)) {
            if (!is_subclass_of($cases, \BackedEnum::class, true)) {
                throw new InvalidArgumentException(sprintf('"%s" is not a "BackedEnum" class.', $cases));
            }

            $cases = $cases::cases();
        } else {
            $class = null;

            foreach ($cases as $case) {
                if (!$case instanceof \BackedEnum) {
                    throw new InvalidArgumentException(sprintf('Case must be a "BackedEnum" instance, "%s" given.', get_debug_type($case)));
                }

                $class ??= $case::class;

                if (!$case instanceof $class) {

  protected function setCsrfTokenSeedInTestEnvironment() {
    $session_data = $this->container->get('session_handler.write_safe')->read($this->getSession()->getCookie($this->getSessionName()));
    $csrf_token_seed = unserialize(explode('_sf2_meta|', $session_data)[1])['s'];
    $this->container->get('session_manager.metadata_bag')->setCsrfTokenSeed($csrf_token_seed);
  }

  /** * @return \Drupal\big_pipe_test\BigPipePlaceholderTestCase[] */
  protected function getTestCases($has_session = TRUE) {
    return BigPipePlaceholderTestCases::cases($this->container, $this->rootUser);
  }

  /** * Asserts whether arrays A and B are equal, when treated as sets. * * @todo This method is broken. Fix it in * https://www.drupal.org/project/drupal/issues/3144926 * * @internal */
  protected function assertSetsEqual(array $a, array $b): void {

    }
    else {
      $this->assertCount(0, $processed_placeholders);
    }
  }

  /** * @see \Drupal\big_pipe_test\BigPipePlaceholderTestCases */
  public function placeholdersProvider() {
    $cases = BigPipePlaceholderTestCases::cases();

    // Generate $placeholders variable as expected by     // \Drupal\Core\Render\Placeholder\PlaceholderStrategyInterface::processPlaceholders().     $placeholders = [
      $cases['html']->placeholder                             => $cases['html']->placeholderRenderArray,
      $cases['html_attribute_value']->placeholder             => $cases['html_attribute_value']->placeholderRenderArray,
      $cases['html_attribute_value_subset']->placeholder      => $cases['html_attribute_value_subset']->placeholderRenderArray,
      $cases['edge_case__invalid_html']->placeholder          => $cases['edge_case__invalid_html']->placeholderRenderArray,
      $cases['edge_case__html_non_lazy_builder']->placeholder => $cases['edge_case__html_non_lazy_builder']->placeholderRenderArray,
      $cases['exception__lazy_builder']->placeholder          => $cases['exception__lazy_builder']->placeholderRenderArray,
      $cases['exception__embedded_response']->placeholder     => $cases['exception__embedded_response']->placeholderRenderArray,
    ];

$changelogEntries = explode("\n", $changelogPart);
        foreach ($changelogEntries as $changelogEntry) {
            if (!str_starts_with($changelogEntry, '*')) {
                continue;
            }
            // Remove leading asterisk and spaces around changelog entry             $changelogEntry = trim(substr($changelogEntry, 1));
            if ($changelogEntry === '') {
                continue;
            }

            foreach (ChangelogKeyword::cases() as $allowedChangelogKeyword) {
                if (str_starts_with($changelogEntry, $allowedChangelogKeyword->value)) {
                    continue 2;
                }
            }
            $context->buildViolation(sprintf(self::VIOLATION_MESSAGE_STARTING_KEYWORD, $changelogEntry, implode(', ', array_column(ChangelogKeyword::cases(), 'value'))))
                ->atPath($currentSection->name)
                ->addViolation();
        }
    }
}

    public function __construct(private readonly ChangelogReleaseExporter $releaseExporter)
    {
        parent::__construct();
    }

    protected function configure(): void
    {
        $this->addArgument('version', InputArgument::OPTIONAL, 'A version of release. It should be 4-digits type. Please leave it blank for the unreleased version.')
            ->addOption('path', 'p', InputOption::VALUE_REQUIRED, 'Renders the output of the command in a markdown file under the given path', '');
        foreach (ChangelogSection::cases() as $changelogSection) {
            $this->addOption($changelogSection->name, null, InputOption::VALUE_NONE, sprintf('Returns all documented changes in the "%s" section', $changelogSection->value));
        }
        $this->addOption('include-feature-flags', null, InputOption::VALUE_NONE, 'Returns all changes, including features which are still behind a feature flag.')
            ->addOption('keys-only', null, InputOption::VALUE_NONE, 'Returns only Jira ticket keys of all changes made.');
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $IOHelper = new SymfonyStyle($input, $output);
        $IOHelper->title('Get all changes made in the given version');

final class EnumType extends AbstractType
{
    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver
            ->setRequired(['class'])
            ->setAllowedTypes('class', 'string')
            ->setAllowedValues('class', enum_exists(...))
            ->setDefault('choices', static fn (Options $options): array => $options['class']::cases())
            ->setDefault('choice_label', static fn (\UnitEnum $choice) => $choice instanceof TranslatableInterface ? $choice : $choice->name)
            ->setDefault('choice_value', static function DOptions $options): ?\Closure {
                if (!is_a($options['class'], \BackedEnum::class, true)) {
                    return null;
                }

                return static function D?\BackedEnum $choice): ?string {
                    if (null === $choice) {
                        return null;
                    }

$this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('"Symfony\Component\Config\Definition\EnumNode" only supports scalar, enum, or null values, "stdClass" given.');

        new EnumNode('ccc', null, [new \stdClass()]);
    }

    public function testTwoDifferentEnumsThrows()
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('"Symfony\Component\Config\Definition\EnumNode" only supports one type of enum, "Symfony\Component\Config\Tests\Fixtures\TestEnum" and "Symfony\Component\Config\Tests\Fixtures\TestEnum2" passed.');

        new EnumNode('ccc', null, [...TestEnum::cases(), TestEnum2::Ccc]);
    }
}

/** * Returns all BigPipe placeholder test case render arrays. * * @return array */
  public function test() {
    $has_session = \Drupal::service('session_configuration')->hasSession(\Drupal::requestStack()->getMainRequest());

    $build = [];

    $cases = BigPipePlaceholderTestCases::cases(\Drupal::getContainer());

    // 1. HTML placeholder: status messages. Drupal renders those automatically,     // so all that we need to do in this controller is set a message.     if ($has_session) {
      // Only set a message if a session already exists, otherwise we always       // trigger a session, which means we can't test no-session requests.       \Drupal::messenger()->addStatus('Hello from BigPipe!');
    }
    $build['html'] = $cases['html']->renderArray;

    // 2. HTML attribute value placeholder: form action.

        yield 'parameters_1' => new ParameterBag([
            'integer' => 12,
            'string' => 'Hello world!',
            'boolean' => true,
            'array' => [12, 'Hello world!', true],
        ]);

        yield 'parameters_enums' => new ParameterBag([
            'unit_enum' => FooUnitEnum::BAR,
            'backed_enum' => Suit::Hearts,
            'array_of_enums' => Suit::cases(),
            'map' => [
                'mixed' => [Suit::Hearts, FooUnitEnum::BAR],
                'single' => FooUnitEnum::BAR,
            ],
        ]);
    }

    public static function getContainerParameter()
    {
        $builder = new ContainerBuilder();
        $builder->setParameter('database_name', 'symfony');