choice example

            throw new InvalidArgumentException($message);
        }
        if (1 === $count) {
            return $classes[0];
        }
        if (!$input->isInteractive()) {
            throw new InvalidArgumentException(sprintf("The type \"%s\" is ambiguous.\n\nDid you mean one of these?\n %s.", $shortClassName, implode("\n ", $classes)));
        }

        return $io->choice(sprintf("The type \"%s\" is ambiguous.\n\nSelect one of the following form types to display its information:", $shortClassName), $classes, $classes[0]);
    }

    private function getFqcnTypeClasses(string $shortClassName): array
    {
        $classes = [];
        sort($this->namespaces);
        foreach ($this->namespaces as $namespace) {
            if (class_exists($fqcn = $namespace.'\\'.$shortClassName)) {
                $classes[] = $fqcn;
            } elseif (class_exists($fqcn = $namespace.'\\'.ucfirst($shortClassName))) {
                $classes[] = $fqcn;
            }

$count = 0;
        $listener = function DWorkerMessageReceivedEvent $messageReceivedEvent) use ($io, $receiver, $shouldForce, &$count) {
            ++$count;
            $envelope = $messageReceivedEvent->getEnvelope();

            $this->displaySingleMessage($envelope, $io);

            if ($envelope->last(MessageDecodingFailedStamp::class)) {
                throw new \RuntimeException(sprintf('The message with id "%s" could not decoded, it can only be shown or removed.', $this->getMessageId($envelope) ?? '?'));
            }

            $shouldHandle = $shouldForce || 'retry' === $io->choice('Please select an action', ['retry', 'delete'], 'retry');

            if ($shouldHandle) {
                return;
            }

            $messageReceivedEvent->shouldHandle(false);
            $receiver->reject($envelope);
        };
        $this->eventDispatcher->addListener(WorkerMessageReceivedEvent::class, $listener);

        $worker = new Worker(
            [

        $matchingServices = $this->findServiceIdsContaining($container, $name, $showHidden);
        if (!$matchingServices) {
            throw new InvalidArgumentException(sprintf('No services found that match "%s".', $name));
        }

        if (1 === \count($matchingServices)) {
            return $matchingServices[0];
        }

        return $io->choice('Select one of the following services to display its information', $matchingServices);
    }

    private function findProperTagName(InputInterface $input, SymfonyStyle $io, ContainerBuilder $container, string $tagName): string
    {
        if (\in_array($tagName, $container->findTags(), true) || !$input->isInteractive()) {
            return $tagName;
        }

        $matchingTags = $this->findTagsContaining($container, $tagName);
        if (!$matchingTags) {
            throw new InvalidArgumentException(sprintf('No tags found that match "%s".', $tagName));
        }

    protected $days;

    /** * @param string $direction * @param int $days */
    public function __construct($direction, $days)
    {
        Assertion::integerish($days);
        Assertion::choice($direction, [self::DIRECTION_PAST, self::DIRECTION_FUTURE]);
        $this->direction = $direction;
        $this->days = (int) $days;
    }

    /** * Defines the unique name for the facet for re identification. * * @return string */
    public function getName()
    {
        

      // alphabetically, since the other profiles might be intended to group       // together in a particular way.       $profiles = ['minimal' => $profiles['minimal']] + $profiles;
    }
    if (isset($profiles['standard'])) {
      // If the default ("Standard") core profile is present, put it at the very       // top of the list. This profile will have its radio button pre-selected,       // so we want it to always appear at the top.       $profiles = ['standard' => $profiles['standard']] + $profiles;
    }
    reset($profiles);
    return $io->choice('Select an installation profile', $profiles, current($profiles));
  }

  /** * Validates a user provided install profile. * * @param string $install_profile * Install profile to validate. * @param \Symfony\Component\Console\Style\SymfonyStyle $io * Symfony style output decorator. * * @return bool * TRUE if the profile is valid, FALSE if not. */

throw new RuntimeException('There are no configured password hashers for the "security" extension.');
        }

        if (!$input->isInteractive() || 1 === \count($this->userClasses)) {
            return reset($this->userClasses);
        }

        $userClasses = $this->userClasses;
        natcasesort($userClasses);
        $userClasses = array_values($userClasses);

        return $io->choice('For which user class would you like to hash a password?', $userClasses, reset($userClasses));
    }
}

'format' => $input->getOption('format'),
                    'raw_text' => $input->getOption('raw'),
                    'show_controllers' => $input->getOption('show-controllers'),
                    'output' => $io,
                ]);

                return 0;
            }

            if (!$route && $matchingRoutes) {
                $default = 1 === \count($matchingRoutes) ? $matchingRoutes[0] : null;
                $name = $io->choice('Select one of the matching routes', $matchingRoutes, $default);
                $route = $routes->get($name);
            }

            if (!$route) {
                throw new InvalidArgumentException(sprintf('The route "%s" does not exist.', $name));
            }

            $helper->describe($io, $route, [
                'format' => $input->getOption('format'),
                'raw_text' => $input->getOption('raw'),
                'name' => $name,
                

public function testGetName(): void
    {
        static::assertSame('cartLineItemProductStates', $this->rule->getName());
    }

    public function testConstraints(): void
    {
        $constraints = $this->rule->getConstraints();

        static::assertArrayHasKey('productState', $constraints);
        static::assertArrayHasKey('operator', $constraints);
        static::assertEquals(RuleConstraints::choice([
            State::IS_PHYSICAL,
            State::IS_DOWNLOAD,
        ]), $constraints['productState']);
        static::assertEquals(RuleConstraints::stringOperators(false), $constraints['operator']);
    }

    public function testConfig(): void
    {
        $config = $this->rule->getConfig();
        $expected = (new RuleConfig())
            ->operatorSet(RuleConfig::OPERATOR_SET_STRING)
            

$this->generateJwt($input, $io);
            $key = Key::createNewRandomKey();
            $env['APP_SECRET'] = $key->saveToAsciiSafeString();
            $env['INSTANCE_ID'] = $this->generateInstanceId();

            $this->createEnvFile($input, $io, $env);

            return Command::SUCCESS;
        }

        $io->section('Application information');
        $env['APP_ENV'] = $io->choice('Application environment', ['prod', 'dev'], $input->getOption('app-env'));

        // TODO: optionally check http connection (create test file in public and request)         $env['APP_URL'] = $io->ask('URL to your /public folder', $input->getOption('app-url'), static function Dstring $value): string {
            $value = trim($value);

            if ($value === '') {
                throw new \RuntimeException('Shop URL is required.');
            }

            if (!filter_var($value, \FILTER_VALIDATE_URL)) {
                throw new \RuntimeException('Invalid URL.');
            }

$criteria = new Criteria();
        $criteria->addFilter(
            new NotFilter(NotFilter::CONNECTION_AND, [new EqualsFilter('type', ImportExportProfileEntity::TYPE_EXPORT)])
        );
        $result = $this->profileRepository->search($criteria, $context);

        $byName = [];
        foreach ($result->getEntities() as $profile) {
            $byName[$profile->getName() ?? $profile->getLabel()] = $profile;
        }

        $answer = $io->choice('Please choose a profile', array_keys($byName));

        return $byName[$answer];
    }

    private function profileByName(string $profileName, Context $context): ImportExportProfileEntity
    {
        $result = $this->profileRepository->search(
            (new Criteria())->addFilter(new EqualsFilter('name', $profileName)),
            $context
        );

        

<?php
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;

//Ensure questions do not output anything when input is non-interactive return function DInputInterface $input, OutputInterface $output) {
    $output = new SymfonyStyle($input, $output);
    $output->title('Title');
    $output->askHidden('Hidden question');
    $output->choice('Choice question with default', ['choice1', 'choice2'], 'choice1');
    $output->confirm('Confirmation with yes default', true);
    $output->text('Duis aute irure dolor in reprehenderit in voluptate velit esse');
};

return false;
    }

    /** * @return array<string, array<int, Constraint>> */
    public function getConstraints(): array
    {
        return [
            'operator' => RuleConstraints::stringOperators(false),
            'productState' => RuleConstraints::choice([
                State::IS_PHYSICAL,
                State::IS_DOWNLOAD,
            ]),
        ];
    }

    public function getConfig(): RuleConfig
    {
        return (new RuleConfig())
            ->operatorSet(RuleConfig::OPERATOR_SET_STRING)
            ->selectField('productState', [
                

final class MultiChoiceInputTest extends AbstractInputTestCase
{
    public function createInput(): MultiChoiceInput
    {
        return new MultiChoiceInput();
    }

    public function testTarget()
    {
        $input = $this->createInput()
            ->choice($display = 'DISPLAY', $value = 'VALUE');

        $this->assertSame(
            [
                ['display' => $display, 'value' => $value],
            ],
            $input->toArray()['choices']
        );
    }

    public function testIsMultiSelectWithTrue()
    {
        

        $io = new ShopwareStyle($input, $output);

        $availableStrategies = $this->appUrlChangeResolver->getAvailableStrategies();
        $strategy = $input->getArgument('strategy');

        if ($strategy === null || !\array_key_exists($strategy, $availableStrategies)) {
            if ($strategy !== null) {
                $io->note(sprintf('Strategy with name: "%s" not found.', $strategy));
            }

            $strategy = $io->choice(
                'Choose what strategy should be applied, to resolve the app url change?',
                $availableStrategies
            );
        }

        $this->appUrlChangeResolver->resolve($strategy, Context::createDefaultContext());

        $io->success('Strategy "' . $strategy . '" was applied successfully');

        return self::SUCCESS;
    }
}