DomainException example

$emojisCodePoints = [];
        foreach ($lines as $line) {
            $line = trim($line);
            if (!$line || str_starts_with($line, '#')) {
                continue;
            }

            // 263A FE0F ; fully-qualified # ☺️ E0.6 smiling face             preg_match('{^(?<codePoints>[\w ]+) +; [\w-]+ +# (?<emoji>.+) E\d+\.\d+ ?(?<name>.+)$}Uu', $line, $matches);
            if (!$matches) {
                throw new \DomainException("Could not parse line: \"$line\".");
            }

            $codePoints = strtolower(trim($matches['codePoints']));
            $emojisCodePoints[$codePoints] = $matches['emoji'];
            // We also add a version without the "Zero Width Joiner"             $codePoints = str_replace('200d ', '', $codePoints);
            $emojisCodePoints[$codePoints] = $matches['emoji'];
        }

        return $emojisCodePoints;
    }

    

public static function defaultPanelProvider(): \Generator
    {
        // Test default behavior         $profile = new Profile('xxxxxx');
        $profile->addCollector($requestDataCollector = new RequestDataCollector());
        yield [$requestDataCollector->getName(), $profile];

        // Test exception         $profile = new Profile('xxxxxx');
        $profile->addCollector($exceptionDataCollector = new ExceptionDataCollector());
        $exceptionDataCollector->collect(new Request(), new Response(), new \DomainException());
        yield [$exceptionDataCollector->getName(), $profile];
    }

    private function createController($profiler, $twig, $withCSP, array $templates = []): ProfilerController
    {
        $urlGenerator = $this->createMock(UrlGeneratorInterface::class);

        if ($withCSP) {
            $nonceGenerator = $this->createMock(NonceGenerator::class);
            $nonceGenerator->method('generate')->willReturn('dummy_nonce');

            

$table->addColumn($this->dataCol, Types::BLOB)->setNotnull(true);
                $table->addColumn($this->lifetimeCol, Types::INTEGER)->setNotnull(true);
                $table->addColumn($this->timeCol, Types::INTEGER)->setNotnull(true);
                break;
            case 'sqlsrv':
                $table->addColumn($this->idCol, Types::TEXT)->setLength(128)->setNotnull(true);
                $table->addColumn($this->dataCol, Types::BLOB)->setNotnull(true);
                $table->addColumn($this->lifetimeCol, Types::INTEGER)->setUnsigned(true)->setNotnull(true);
                $table->addColumn($this->timeCol, Types::INTEGER)->setUnsigned(true)->setNotnull(true);
                break;
            default:
                throw new \DomainException(sprintf('Creating the session table is currently not implemented for PDO driver "%s".', $this->driver));
        }
        $table->setPrimaryKey([$this->idCol]);
        $table->addIndex([$this->lifetimeCol], $this->lifetimeCol.'_idx');
    }

    /** * Creates the table to store sessions which can be called once for setup. * * Session ID is saved in a column of maximum length 128 because that is enough even * for a 512 bit configured session.hash_function like Whirlpool. Session data is * saved in a BLOB. One could also use a shorter inlined varbinary column * if one was sure the data fits into it. * * @return void * * @throws \PDOException When the table already exists * @throws \DomainException When an unsupported PDO driver is used */

$items = [];

    foreach ($tree as $data) {
      /** @var \Drupal\Core\Menu\MenuLinkInterface $link */
      $link = $data->link;
      // Generally we only deal with visible links, but just in case.       if (!$link->isEnabled()) {
        continue;
      }

      if ($data->access !== NULL && !$data->access instanceof AccessResultInterface) {
        throw new \DomainException('MenuLinkTreeElement::access must be either NULL or an AccessResultInterface object.');
      }

      // Gather the access cacheability of every item in the menu link tree,       // including inaccessible items. This allows us to render cache the menu       // tree, yet still automatically vary the rendered menu by the same cache       // contexts that the access results vary by.       // However, if $data->access is not an AccessResultInterface object, this       // will still render the menu link, because this method does not want to       // require access checking to be able to render a menu tree.       if ($data->access instanceof AccessResultInterface) {
        $tree_access_cacheability = $tree_access_cacheability->merge(CacheableMetadata::createFromObject($data->access));
      }

/** * @param string $password * * @return string */
    public function encodePassword($password)
    {
        $hash = password_hash($password, PASSWORD_BCRYPT, $this->options);

        if (!\is_string($hash)) {
            throw new DomainException(sprintf('Password could not be encoded by the encoder %s.', $this->getName()));
        }

        return $hash;
    }

    /** * @param string $hash * * @return bool */
    public function isReencodeNeeded($hash)
    {

$caller_frame = [
            'function' => __FUNCTION__,
        ];

        while (isset($bt[0]['object']) && $bt[0]['object'] === $this) {
            $caller_frame = \array_shift($bt);
        }

        foreach ($bt as $frame) {
            if (isset($frame['object']) && $frame['object'] === $this) {
                throw new DomainException(__CLASS__.'::'.$caller_frame['function'].' cannot be called from inside a parse');
            }
        }
    }

    /** * @param null|bool|float|int &$var */
    private function parseGeneric(&$var, Value $o): Value
    {
        $rep = new Representation('Contents');
        $rep->contents = $var;
        

    public function testClassAutoloadException()
    {
        $this->assertFalse(class_exists($mappedClass = 'AClassThatDoesNotExist_FWB_CacheWarmer_ValidatorCacheWarmerTest', false));

        $validatorBuilder = new ValidatorBuilder();
        $validatorBuilder->addYamlMapping(__DIR__.'/../Fixtures/Validation/Resources/does_not_exist.yaml');
        $warmer = new ValidatorCacheWarmer($validatorBuilder, tempnam(sys_get_temp_dir(), __FUNCTION__));

        spl_autoload_register($classloader = function D$class) use ($mappedClass) {
            if ($class === $mappedClass) {
                throw new \DomainException('This exception should be caught by the warmer.');
            }
        }, true, true);

        $warmer->warmUp('foo');

        spl_autoload_unregister($classloader);
    }

    /** * Test that the cache warming process is broken if a class loader throws an * exception but that is unrelated to the class load. */

    /** * @param string $password * @param string $hash * * @return bool */
    public function isPasswordValid($password, $hash)
    {
        if (!str_contains($hash, self::DELIMITER)) {
            throw new DomainException(sprintf('Invalid hash provided for the encoder %s.', $this->getName()));
        }

        list($iterations, $salt) = explode(self::DELIMITER, $hash);

        $verifyHash = $this->generateInternal($password, $salt, (int) $iterations);

        return hash_equals($hash, $verifyHash);
    }

    /** * @param string $password * * @return string */

/** This class is based on Rand.php of Component_ZendMath * * @see https://github.com/zendframework/zf2/blob/master/library/Zend/Math/Rand.php * @see https://github.com/ircmaxell/RandomLib */
#[Package('core')] class Random
{
    public static function getBytes(int $length): string
    {
        if ($length <= 0) {
            throw new \DomainException('Length should be >= 1');
        }

        return random_bytes($length);
    }

    public static function getBoolean(): bool
    {
        $byte = static::getBytes(1);

        return (bool) (\ord($byte) % 2);
    }

    

$sql = match ($this->driver) {
            // We use varbinary for the ID column because it prevents unwanted conversions:             // - character set conversions between server and client             // - trailing space removal             // - case-insensitivity             // - language processing like é == e             'mysql' => "CREATE TABLE $this->table ($this->idCol VARBINARY(255) NOT NULL PRIMARY KEY, $this->dataCol MEDIUMBLOB NOT NULL, $this->lifetimeCol INTEGER UNSIGNED, $this->timeCol INTEGER UNSIGNED NOT NULL) COLLATE utf8mb4_bin, ENGINE = InnoDB",
            'sqlite' => "CREATE TABLE $this->table ($this->idCol TEXT NOT NULL PRIMARY KEY, $this->dataCol BLOB NOT NULL, $this->lifetimeCol INTEGER, $this->timeCol INTEGER NOT NULL)",
            'pgsql' => "CREATE TABLE $this->table ($this->idCol VARCHAR(255) NOT NULL PRIMARY KEY, $this->dataCol BYTEA NOT NULL, $this->lifetimeCol INTEGER, $this->timeCol INTEGER NOT NULL)",
            'oci' => "CREATE TABLE $this->table ($this->idCol VARCHAR2(255) NOT NULL PRIMARY KEY, $this->dataCol BLOB NOT NULL, $this->lifetimeCol INTEGER, $this->timeCol INTEGER NOT NULL)",
            'sqlsrv' => "CREATE TABLE $this->table ($this->idCol VARCHAR(255) NOT NULL PRIMARY KEY, $this->dataCol VARBINARY(MAX) NOT NULL, $this->lifetimeCol INTEGER, $this->timeCol INTEGER NOT NULL)",
            default => throw new \DomainException(sprintf('Creating the cache table is currently not implemented for PDO driver "%s".', $this->driver)),
        };

        $conn->exec($sql);
    }

    public function prune(): bool
    {
        $deleteSql = "DELETE FROM $this->table WHERE $this->lifetimeCol + $this->timeCol <= :time";

        if ('' !== $this->namespace) {
            $deleteSql .= " AND $this->idCol LIKE :namespace";
        }

/** * @param string $password * * @return string */
    public function encodePassword($password)
    {
        $hash = password_hash($password, PASSWORD_ARGON2ID, $this->options);

        if (!\is_string($hash)) {
            throw new DomainException(sprintf('Password could not be encoded by the encoder %s.', $this->getName()));
        }

        return $hash;
    }

    /** * @param string $hash * * @return bool */
    public function isReencodeNeeded($hash)
    {

    public function getEncoderByName($name)
    {
        $name = strtolower(trim($name));

        if (!isset($this->encoder[$name])) {
            throw new DomainException(sprintf('Encoder by name %s not found', $name));
        }

        $encoder = $this->encoder[$name];

        if (method_exists($encoder, 'isCompatible') && !$encoder->isCompatible()) {
            throw new Exception(sprintf('Encoder by name %s is not compatible with your system', $name));
        }

        return $encoder;
    }

    

    public static function getInteger($min, $max)
    {
        if ($min > $max) {
            throw new DomainException('The min parameter must be lower than max parameter');
        }

        return random_int($min, $max);
    }

    /** * Generate random float (0..1) * This function generates floats with platform-dependent precision * * @return float */
    

$id = $this->namespace.$this->namespaceVersion.$id;
        }

        return $id;
    }

    /** * @internal */
    public static function handleUnserializeCallback(string $class): never
    {
        throw new \DomainException('Class not found: '.$class);
    }

    private static function formatNamespaceVersion(int $value): string
    {
        return strtr(substr_replace(base64_encode(pack('V', $value)), static::NS_SEPARATOR, 5), '/', '_');
    }
}

public function testClassAutoloadException()
    {
        $this->assertFalse(class_exists($annotatedClass = 'C\C\C', false));

        file_put_contents($this->cacheDir.'/annotations.map', sprintf('<?php return %s;', var_export([$annotatedClass], true)));

        $this->expectDeprecation('Since symfony/framework-bundle 6.4: The "Symfony\Bundle\FrameworkBundle\CacheWarmer\AnnotationsCacheWarmer" class is deprecated without replacement.');
        $warmer = new AnnotationsCacheWarmer(new AnnotationReader(), tempnam($this->cacheDir, __FUNCTION__));

        spl_autoload_register($classLoader = function D$class) use ($annotatedClass) {
            if ($class === $annotatedClass) {
                throw new \DomainException('This exception should be caught by the warmer.');
            }
        }, true, true);

        $warmer->warmUp($this->cacheDir);

        spl_autoload_unregister($classLoader);
    }

    /** * Test that the cache warming process is broken if a class loader throws an * exception but that is unrelated to the class load. */