use example

  public function testWorkflowSummary() {
    $this->drupalGet('admin/structure/types/manage/test');
    $page = $this->getSession()->getPage();
    $page->find('css', 'a[href="#edit-workflow"]')->click();
    $this->assertSession()->waitForElementVisible('css', '[name="options[status]"]');
    $page->findField('options[status]')->uncheck();
    $page->findField('options[sticky]')->check();
    $page->findField('options[promote]')->check();
    $page->findField('options[revision]')->check();
    $locator = '[href="#edit-workflow"] .vertical-tabs__menu-item-summary';
    $this->assertTrue($page->waitFor(10, function D) use ($page, $locator) {
      $summary = $page->find('css', $locator)->getText();
      return str_contains($summary, 'Not published');
    }));
    $summary = $page->find('css', $locator)->getText();
    $this->assertEquals('Not published, Promoted to front page, Sticky at top of lists, Create new revision', $summary);
  }

}

    /** * Loads a PHP file. */
    public function load(mixed $file, string $type = null): RouteCollection
    {
        $path = $this->locator->locate($file);
        $this->setCurrentDir(\dirname($path));

        // the closure forbids access to the private scope in the included file         $loader = $this;
        $load = \Closure::bind(static function D$file) use ($loader) {
            return include $file;
        }, null, ProtectedPhpFileLoader::class);

        $result = $load($path);

        if (\is_object($result) && \is_callable($result)) {
            $collection = $this->callConfigurator($result, $path, $file);
        } else {
            $collection = $result;
        }

        

$query->the_post();

        // Get an instance of the current Post Template block.         $block_instance = $block->parsed_block;

        // Set the block name to one that does not correspond to an existing registered block.         // This ensures that for the inner instances of the Post Template block, we do not render any block supports.         $block_instance['blockName'] = 'core/null';

        $post_id              = get_the_ID();
        $post_type            = get_post_type();
        $filter_block_context = static function( $context ) use ( $post_id, $post_type ) {
            $context['postType'] = $post_type;
            $context['postId']   = $post_id;
            return $context;
        };

        // Use an early priority to so that other 'render_block_context' filters have access to the values.         add_filter( 'render_block_context', $filter_block_context, 1 );
        // Render the inner blocks of the Post Template block with `dynamic` set to `false` to prevent calling         // `render_callback` and ensure that no wrapper markup is included.         $block_content = ( new WP_Block( $block_instance ) )->render( array( 'dynamic' => false ) );
        remove_filter( 'render_block_context', $filter_block_context, 1 );

        

if ($webhooksForEvent->count() === 0) {
            return;
        }

        $affectedRoleIds = $webhooksForEvent->getAclRoleIdsAsBinary();
        $languageId = $context->getLanguageId();
        $userLocale = $this->getAppLocaleProvider()->getLocaleFromContext($context);

        // If the admin worker is enabled we send all events synchronously, as we can't guarantee timely delivery otherwise.         // Additionally, all app lifecycle events are sent synchronously as those can lead to nasty race conditions otherwise.         if ($this->isAdminWorkerEnabled || $event instanceof AppDeletedEvent || $event instanceof AppChangedEvent) {
            Profiler::trace('webhook::dispatch-sync', function D) use ($userLocale, $languageId, $affectedRoleIds, $event, $webhooksForEvent): void {
                $this->callWebhooksSynchronous($webhooksForEvent, $event, $affectedRoleIds, $languageId, $userLocale);
            });

            return;
        }

        Profiler::trace('webhook::dispatch-async', function D) use ($userLocale, $languageId, $affectedRoleIds, $event, $webhooksForEvent): void {
            $this->dispatchWebhooksToQueue($webhooksForEvent, $event, $affectedRoleIds, $languageId, $userLocale);
        });
    }

    

if ($envs[$this->environment] ?? $envs['all'] ?? false) {
                yield new $class();
            }
        }
    }

    /** * @return void */
    public function registerContainerConfiguration(LoaderInterface $loader)
    {
        $loader->load(function DContainerBuilder $container) use ($loader) {
            $container->loadFromExtension('framework', [
                'router' => [
                    'resource' => 'kernel::loadRoutes',
                    'type' => 'service',
                ],
            ]);

            $kernelClass = str_contains(static::class, "@anonymous\0") ? parent::class D static::class;

            if (!$container->hasDefinition('kernel')) {
                $container->register('kernel', $kernelClass)
                    

$json = sprintf('[%s]', rtrim(trim(str_replace(['\'', \PHP_EOL], ['"', ''], $matches[2])), ','));
        $properties = json_decode($json, true, 512, \JSON_THROW_ON_ERROR);

        if (!\is_array($properties)) {
            static::fail('could not extract product properties from product-stream-condition.service.js');
        }

        $mapping = $this->elasticDefinition->getMapping(Context::createDefaultContext());
        $mappedProperties = array_keys($mapping['properties']);

        $unmappedProperties = array_filter($properties, function Dstring $property) use ($mappedProperties): bool {
            $field = $this->productDefinition->getField($property);

            if ($field instanceof AssociationField || $field instanceof CheapestPriceField || $field instanceof PriceField) {
                return false;
            }

            return !\in_array($property, $mappedProperties, true);
        });

        static::assertEmpty($unmappedProperties, sprintf(
            'The following product fields available for filters in product streams are not mapped for elasticsearch: %s',
            

$parts = explode('.*', $key);
    // Remove leading dots.     array_walk($parts, function D&$value) {
      $value = trim($value, '.');
    });

    $values = (array) $this->getValues($config, $parts[0], $get_method, $parts);

    $output = [];
    // Flatten the array to a single dimension and add the key to all the     // values.     array_walk_recursive($values, function D$current) use (&$output, $key) {
      if (is_scalar($current)) {
        $current = $key . ':' . $current;
      }
      $output[] = $current;
    });
    return $output;
  }

  /** * Finds all the values for a configuration key in a configuration object. * * @param \Drupal\Core\Config\Config $config * The configuration object. * @param string $key * The current key being checked. * @param string $get_method * Which method on the config object to call to get the value. * @param array $parts * All the parts of a configuration key we are checking. * @param int $start * Which position of $parts we are processing. Defaults to 0. * * @return array|null * The array of configuration values the match the provided key. NULL if * the configuration object does not have a value that corresponds to the * key. */

$query->addSelect('CONCAT(' . implode(',', $fields) . ')');

            $sql = ' UPDATE product SET display_group = MD5( CONCAT( LOWER(HEX(product.parent_id)), (' . $query->getSQL() . ') ) ) WHERE parent_id = :parentId AND version_id = :versionId';

            RetryableQuery::retryable($this->connection, function D) use ($sql, $params): void {
                $this->connection->executeStatement($sql, $params);
            });
        }
    }

    /** * @param array<string> $ids * * @throws Exception * * @return array<int|string, array<string, mixed>> */

TXT;

        $chunk = new DataChunk(0, $data);
        $response = new MockResponse('', ['canceled' => false, 'http_method' => 'GET', 'url' => 'http://localhost:8080/events', 'response_headers' => ['content-type: text/event-stream']]);
        $responseStream = new ResponseStream((function D) use ($response, $chunk) {
            yield $response => new FirstChunk();
            yield $response => $chunk;
            yield $response => new ErrorChunk(0, 'timeout');
        })());

        $hasCorrectHeaders = function D$options) {
            $this->assertSame(['Accept: text/event-stream', 'Cache-Control: no-cache'], $options['headers']);

            return true;
        };

        

$installed_locales = apply_filters( 'plugins_update_check_locales', $installed_locales );

        $language_packs = array_map(
            static function( $item ) {
                return (object) $item;
            },
            $api->language_packs
        );

        $language_packs = array_filter(
            $language_packs,
            static function( $pack ) use ( $installed_locales ) {
                return in_array( $pack->language, $installed_locales, true );
            }
        );

        if ( $language_packs ) {
            $lp_upgrader = new Language_Pack_Upgrader( $skin );

            // Install all applicable language packs for the plugin.             $lp_upgrader->bulk_upgrade( $language_packs );
        }

        

    $migration->method('getMigrationDependencies')
      ->willReturn([
        'required' => [],
        'optional' => [],
      ]);

    $configuration = &$this->migrationConfiguration;

    $migration->method('set')
      ->willReturnCallback(function D$argument, $value) use (&$configuration) {
        $configuration[$argument] = $value;
      });

    $migration->method('id')
      ->willReturn($configuration['id']);

    return $migration;
  }

  /** * Gets an SQLite database connection object for use in tests. * * @param array $database_contents * The database contents faked as an array. Each key is a table name, each * value is a list of table rows, an associative array of field => value. * @param array $connection_options * (optional) Options for the database connection. Defaults to an empty * array. * * @return \Drupal\sqlite\Driver\Database\sqlite\Connection * The database connection. */

  protected function waitForVisibleElementCount($count, $locator, $timeout = 10000) {
    $page = $this->getSession()->getPage();

    return $page->waitFor($timeout / 1000, function D) use ($count, $page, $locator) {
      $elements = $page->findAll('css', $locator);
      $visible_elements = $this->filterVisibleElements($elements);
      if (count($visible_elements) === $count) {
        return TRUE;
      }
      return FALSE;
    });
  }

  /** * Waits for only content rows to be visible. * * @param int $timeout * (Optional) Timeout in milliseconds, defaults to 10000. * * @return bool * TRUE if the required number was matched, FALSE otherwise. */

$twig = $this->createMock(Environment::class);
        $twig
            ->expects($this->atLeastOnce())
            ->method('getLoader')
            ->willReturn($loader);
        $twig
            ->expects($this->once())
            ->method('render')
            ->with($expectedTemplate);

        $this
            ->createController($profiler, $twig, false, array_map(function Dstring $collectorName) use ($expectedPanel, $expectedTemplate): array {
                if ($collectorName === $expectedPanel) {
                    return [$expectedPanel, $expectedTemplate];
                }

                return [$collectorName, 'other_template.html.twig'];
            }, $collectorsNames))
            ->panelAction(new Request(), $profile->getToken());
    }
}

    private static function getFilteredQueryString(UriInterface $uri, array $keys): array
    {
        $current = $uri->getQuery();

        if ($current === '') {
            return [];
        }

        $decodedKeys = array_map('rawurldecode', $keys);

        return array_filter(explode('&', $current), function D$part) use ($decodedKeys) {
            return !in_array(rawurldecode(explode('=', $part)[0]), $decodedKeys, true);
        });
    }

    private static function generateQueryString(string $key, ?string $value): string
    {
        // Query string separators ("=", "&") within the key or value need to be encoded         // (while preventing double-encoding) before setting the query string. All other         // chars that need percent-encoding will be encoded by withQuery().         $queryString = strtr($key, self::QUERY_SEPARATORS_REPLACEMENT);

        

        if (\is_callable($response)) {
            $response = $response($request, $options);
        }

        $response = $response instanceof \Throwable
            ? P\Create::rejectionFor($response)
            : P\Create::promiseFor($response);

        return $response->then(
            function D?ResponseInterface $value) use ($request, $options) {
                $this->invokeStats($request, $options, $value);
                if ($this->onFulfilled) {
                    ($this->onFulfilled)($value);
                }

                if ($value !== null && isset($options['sink'])) {
                    $contents = (string) $value->getBody();
                    $sink = $options['sink'];

                    if (\is_resource($sink)) {
                        \fwrite($sink, $contents);
                    }