CodeExplorer

open example

$message_table_name does not exist");
  }

  /** * Tests the getQualifiedMapTable method with a prefixed database. */
  public function testGetQualifiedMapTablePrefix() {
    $connection_options = [
      'database' => ':memory:',
      'prefix' => 'prefix',
    ];
    $pdo = Connection::open($connection_options);
    $this->database = new Connection($pdo, $connection_options);
    $qualified_map_table = $this->getIdMap()->getQualifiedMapTableName();
    // The SQLite driver is a special flower. It will prefix tables with     // PREFIX.TABLE, instead of the standard PREFIXTABLE.     // @see \Drupal\sqlite\Driver\Database\sqlite\Connection::__construct()     $this->assertEquals('prefix.migrate_map_sql_idmap_test', $qualified_map_table);
  }

  /** * Tests all the iterator methods in one swing. * * The iterator methods are: * - Sql::rewind() * - Sql::next() * - Sql::valid() * - Sql::key() * - Sql::current() */

  protected function getDatabase(array $source_data) {
    // Create an in-memory SQLite database. Plugins can interact with it like     // any other database, and it will cease to exist when the connection is     // closed.     $connection_options = ['database' => ':memory:'];
    $pdo = Connection::open($connection_options);
    $connection = new Connection($pdo, $connection_options);

    // Create the tables and fill them with data.     foreach ($source_data as $table => $rows) {
      // Use the biggest row to build the table schema.       $counts = array_map('count', $rows);
      asort($counts);
      end($counts);
      $pilot = $rows[key($counts)];

      $connection->schema()

class StrictSessionHandlerTest extends TestCase
{
    public function testOpen()
    {
        $handler = $this->createMock(\SessionHandlerInterface::class);
        $handler->expects($this->once())->method('open')
            ->with('path', 'name')->willReturn(true);
        $proxy = new StrictSessionHandler($handler);

        $this->assertInstanceOf(\SessionUpdateTimestampHandlerInterface::class, $proxy);
        $this->assertInstanceOf(AbstractSessionHandler::class, $proxy);
        $this->assertTrue($proxy->open('path', 'name'));
    }

    public function testCloseSession()
    {
        $handler = $this->createMock(\SessionHandlerInterface::class);
        $handler->expects($this->once())->method('close')
            ->willReturn(true);
        $proxy = new StrictSessionHandler($handler);

        $this->assertTrue($proxy->close());
    }

$this->marshaller = $this->createMock(MarshallerInterface::class);
        $this->handler = $this->createMock(AbstractSessionHandler::class);
    }

    public function testOpen()
    {
        $marshallingSessionHandler = new MarshallingSessionHandler($this->handler, $this->marshaller);

        $this->handler->expects($this->once())->method('open')
            ->with('path', 'name')->willReturn(true);

        $marshallingSessionHandler->open('path', 'name');
    }

    public function testClose()
    {
        $marshallingSessionHandler = new MarshallingSessionHandler($this->handler, $this->marshaller);

        $this->handler->expects($this->once())->method('close')->willReturn(true);

        $this->assertTrue($marshallingSessionHandler->close());
    }

private AbstractSessionHandler $handler;
    private MarshallerInterface $marshaller;

    public function __construct(AbstractSessionHandler $handler, MarshallerInterface $marshaller)
    {
        $this->handler = $handler;
        $this->marshaller = $marshaller;
    }

    public function open(string $savePath, string $name): bool
    {
        return $this->handler->open($savePath, $name);
    }

    public function close(): bool
    {
        return $this->handler->close();
    }

    public function destroy(#[\SensitiveParameter] string $sessionId): bool     {
        return $this->handler->destroy($sessionId);
    }

    public function openSection(string $id = null)
    {
        $current = end($this->activeSections);

        if (null !== $id && null === $current->get($id)) {
            throw new \LogicException(sprintf('The section "%s" has been started at an other level and cannot be opened.', $id));
        }

        $this->start('__section__.child', 'section');
        $this->activeSections[] = $current->open($id);
        $this->start('__section__');
    }

    /** * Stops the last started section. * * The id parameter is used to retrieve the events from this section. * * @see getSectionEvents() * * @return void * * @throws \LogicException When there's no started section to be stopped */

$this->currentHandler->expects($this->once())
            ->method('open')
            ->with($savePath, $sessionName)
            ->willReturn(true);

        $this->writeOnlyHandler->expects($this->once())
            ->method('open')
            ->with($savePath, $sessionName)
            ->willReturn(false);

        $result = $this->dualHandler->open($savePath, $sessionName);

        $this->assertTrue($result);
    }

    public function testRead()
    {
        $sessionId = 'xyz';
        $readValue = 'something';

        $this->currentHandler->expects($this->once())
            ->method('read')

public function gc(int $maxlifetime): int|false
    {
        $result = $this->currentHandler->gc($maxlifetime);
        $this->writeOnlyHandler->gc($maxlifetime);

        return $result;
    }

    public function open(string $savePath, string $sessionName): bool
    {
        $result = $this->currentHandler->open($savePath, $sessionName);
        $this->writeOnlyHandler->open($savePath, $sessionName);

        return $result;
    }

    public function read(#[\SensitiveParameter] string $sessionId): string     {
        // No reading from new handler until switch-over         return $this->currentHandler->read($sessionId);
    }

  public function __construct($file_path, array $configuration = []) {
    $this->zip = new \ZipArchive();
    if ($this->zip->open($file_path, $configuration['flags'] ?? 0) !== TRUE) {
      throw new ArchiverException("Cannot open '$file_path'");
    }
  }

  /** * {@inheritdoc} */
  public function add($file_path) {
    $this->zip->addFile($file_path);

    return $this;
  }

class XmlReaderCasterTest extends TestCase
{
    use VarDumperTestTrait;

    private \XMLReader $reader;

    protected function setUp(): void
    {
        $this->reader = new \XMLReader();
        $this->reader->open(__DIR__.'/../Fixtures/xml_reader.xml');
    }

    protected function tearDown(): void
    {
        $this->reader->close();
    }

    public function testParserProperty()
    {
        $this->reader->setParserProperty(\XMLReader::SUBST_ENTITIES, true);

$item = $reader->readItem();
    if (!empty($item)) {
      $uri = $this->fileSystem->tempnam('temporary://', 'po_');
      $header = $reader->getHeader();
      $header->setProjectName($this->config('system.site')->get('name'));
      $header->setLanguageName($language_name);

      $writer = new PoStreamWriter();
      $writer->setURI($uri);
      $writer->setHeader($header);

      $writer->open();
      $writer->writeItem($item);
      $writer->writeItems($reader);
      $writer->close();

      $response = new BinaryFileResponse($uri);
      $response->setContentDisposition('attachment', $filename);
      $form_state->setResponse($response);
    }
    else {
      $this->messenger()->addStatus($this->t('Nothing to export.'));
    }
  }

    public function getHandler(): \SessionHandlerInterface
    {
        return $this->handler;
    }

    // \SessionHandlerInterface
    public function open(string $savePath, string $sessionName): bool
    {
        return $this->handler->open($savePath, $sessionName);
    }

    public function close(): bool
    {
        return $this->handler->close();
    }

    public function read(#[\SensitiveParameter] string $sessionId): string|false     {
        return $this->handler->read($sessionId);
    }

    public function isWrapper(): bool
    {
        return $this->handler instanceof \SessionHandler;
    }

    public function open(string $savePath, string $sessionName): bool
    {
        parent::open($savePath, $sessionName);

        return $this->handler->open($savePath, $sessionName);
    }

    protected function doRead(#[\SensitiveParameter] string $sessionId): string     {
        return $this->handler->read($sessionId);
    }

    public function updateTimestamp(#[\SensitiveParameter] string $sessionId, string $data): bool     {