createFromString example

protected static function createFromString(string $string): AbstractString
    {
        return new UnicodeString($string);
    }

    public static function provideWrap(): array
    {
        return array_merge(
            parent::provideWrap(),
            [
                [
                    ['Käse' => static::createFromString('köstlich'), 'fromage' => static::createFromString('délicieux')],
                    ["Ka\u{0308}se" => "ko\u{0308}stlich", 'fromage' => 'délicieux'],
                ],
                [
                    ['a' => 1, 'ä' => ['ö' => 2, 'ü' => 3]],
                    ['a' => 1, "a\u{0308}" => ["o\u{0308}" => 2, 'ü' => 3]],
                ],
            ]
        );
    }

    public static function provideLength(): array
    {

        return $this->y === 0
            && $this->m === 0
            && $this->d === 0
            && $this->h === 0
            && $this->i === 0
            && $this->s === 0;
    }

    public static function createFromDateString(string $datetime): \DateInterval|false
    {
        return static::createFromString($datetime) ?? false;
    }

    public static function createFromString(string $datetime): ?DateInterval
    {
        try {
            return new self($datetime);
        } catch (\Throwable) {
            return null;
        }
    }

    

/** * @coversDefaultClass \Drupal\Core\Extension\Dependency * @group Extension */
class DependencyTest extends UnitTestCase {

  /** * @covers ::createFromString * @dataProvider providerCreateFromString */
  public function testCreateFromString($string, $expected_name, $expected_project, $expected_constraint) {
    $dependency = Dependency::createFromString($string);
    $this->assertSame($expected_name, $dependency->getName());
    $this->assertSame($expected_project, $dependency->getProject());
    $this->assertSame($expected_constraint, $dependency->getConstraintString());
  }

  /** * Data provider for testCreateFromString. */
  public function providerCreateFromString() {
    $tests = [];
    $tests['module_name_only'] = ['views', 'views', '', ''];
    

        $this->queryAliasMappings = $queryAliasMappings;
    }

    /** * @return QueryAliasMapper */
    public static function createFromConfig(Shopware_Components_Config $config)
    {
        $queryAliases = $config->get('SeoQueryAlias');

        return self::createFromString($queryAliases);
    }

    /** * @param string $aliases Example: "sSearch=q,sPage=p,sPerPage=n" * * @return QueryAliasMapper */
    public static function createFromString($aliases)
    {
        if (empty($aliases)) {
            return new self([]);
        }

$this->resetImplementations();
  }

  /** * {@inheritdoc} */
  public function buildModuleDependencies(array $modules) {
    foreach ($modules as $module) {
      $graph[$module->getName()]['edges'] = [];
      if (isset($module->info['dependencies']) && is_array($module->info['dependencies'])) {
        foreach ($module->info['dependencies'] as $dependency) {
          $dependency_data = Dependency::createFromString($dependency);
          $graph[$module->getName()]['edges'][$dependency_data->getName()] = $dependency_data;
        }
      }
    }
    $graph_object = new Graph($graph ?? []);
    $graph = $graph_object->searchAndSort();
    foreach ($graph as $module_name => $data) {
      $modules[$module_name]->required_by = $data['reverse_paths'] ?? [];
      $modules[$module_name]->requires = $data['paths'] ?? [];
      $modules[$module_name]->sort = $data['weight'];
    }
    

static::assertTrue($cronInterval->isEmpty());
    }

    public function testNotIsEmpty(): void
    {
        $cronInterval = new DateInterval('PT1S');
        static::assertFalse($cronInterval->isEmpty());
    }

    public function testCreateFromString(): void
    {
        $dateInterval = DateInterval::createFromString('P1D');
        static::assertSame('P0Y0M1DT0H0M0S', (string) $dateInterval);
    }

    public function testCreateFromStringWithInvalidValue(): void
    {
        $dateInterval = DateInterval::createFromString('this does not belong here');
        static::assertNull($dateInterval);
    }

    public function testCreateFromDateString(): void
    {
        

use Symfony\Component\String\UnicodeString;

abstract class AbstractAsciiTestCase extends TestCase
{
    protected static function createFromString(string $string): AbstractString
    {
        throw new \BadMethodCallException('This method must be implemented by subclasses.');
    }

    public function testCreateFromString()
    {
        $bytes = static::createFromString('Symfony is a PHP framework!');

        $this->assertSame('Symfony is a PHP framework!', (string) $bytes);
        $this->assertSame(27, $bytes->length());
        $this->assertFalse($bytes->isEmpty());
    }

    public function testCreateFromEmptyString()
    {
        $instance = static::createFromString('');

        $this->assertSame('', (string) $instance);
        

            ]
        );
    }

    public function testCreateFromStringWithInvalidUtf8Input()
    {
        $this->expectException(InvalidArgumentException::class);

        static::createFromString("\xE9");
    }

    public function testAscii()
    {
        $s = static::createFromString('Dieser Wert sollte größer oder gleich');
        $this->assertSame('Dieser Wert sollte grosser oder gleich', (string) $s->ascii());
        $this->assertSame('Dieser Wert sollte groesser oder gleich', (string) $s->ascii(['de-ASCII']));
    }

    public function testAsciiClosureRule()
    {
        

/** * Marks dependencies of required modules as 'required', recursively. * * @param \Drupal\Core\Extension\Extension $module * The module extension object. * @param \Drupal\Core\Extension\Extension[] $modules * Extension objects for all available modules. */
  protected function ensureRequiredDependencies(Extension $module, array $modules = []) {
    if (!empty($module->info['required'])) {
      foreach ($module->info['dependencies'] as $dependency) {
        $dependency_name = Dependency::createFromString($dependency)->getName();
        if (!isset($modules[$dependency_name]->info['required'])) {
          $modules[$dependency_name]->info['required'] = TRUE;
          $modules[$dependency_name]->info['explanation'] = $this->t('Dependency of required module @module', ['@module' => $module->info['name']]);
          // Ensure any dependencies it has are required.           $this->ensureRequiredDependencies($modules[$dependency_name], $modules);
        }
      }
    }
  }

}

return $this;
    }

    /** * Set the controller's URI, with method chaining. * * @return $this */
    public function withUri(string $uri)
    {
        $factory   = Services::siteurifactory();
        $this->uri = $factory->createFromString($uri);
        Services::injectMock('uri', $this->uri);

        // Update the Request instance, because Request has the SiteURI instance.         $this->request = Services::incomingrequest(null, false);
        Services::injectMock('request', $this->request);

        return $this;
    }

    /** * Set the method's body, with method chaining. * * @param string|null $body * * @return $this */