CodeExplorer

ArrayObject example

/** * @param bool $json If the data is already a JSON string */
    public function __construct(mixed $data = null, int $status = 200, array $headers = [], bool $json = false)
    {
        parent::__construct('', $status, $headers);

        if ($json && !\is_string($data) && !is_numeric($data) && !\is_callable([$data, '__toString'])) {
            throw new \TypeError(sprintf('"%s": If $json is set to true, argument $data must be a string or object implementing __toString(), "%s" given.', __METHOD__, get_debug_type($data)));
        }

        $data ??= new \ArrayObject();

        $json ? $this->setJson($data) : $this->setData($data);
    }

    /** * Factory method for chainability. * * Example: * * return JsonResponse::fromJsonString('{"key": "value"}') * ->setSharedMaxAge(300); * * @param string $data The JSON response string * @param int $status The response status code (200 "OK" by default) * @param array $headers An array of response headers */

    public function testMigrateToSqlStorage(): void
    {
        $arrayStorage = new IncrementArrayStorage([
            Uuid::randomHex() => 10,
            Uuid::randomHex() => 4,
        ]);
        $sqlStorage = $this->getContainer()->get(IncrementSqlStorage::class);

        $registry = new IncrementStorageRegistry(
            new \ArrayObject(
                [
                    'SQL' => $sqlStorage,
                    'Array' => $arrayStorage,
                ],
            ),
            'SQL'
        );

        static::assertEmpty($sqlStorage->list());

        $registry->migrate('Array', 'SQL');

class ContextDefinitionIsSatisfiedTest extends UnitTestCase {

  /** * {@inheritdoc} */
  protected function setUp(): void {
    parent::setUp();

    $namespaces = new \ArrayObject([
      'Drupal\\Core\\TypedData' => $this->root . '/core/lib/Drupal/Core/TypedData',
      'Drupal\\Core\\Validation' => $this->root . '/core/lib/Drupal/Core/Validation',
      'Drupal\\Tests\\Core\\Plugin\\Fixtures' => $this->root . '/core/tests/Drupal/Tests/Core/Plugin/Fixtures',
    ]);
    $cache_backend = new NullBackend('cache');
    $module_handler = $this->prophesize(ModuleHandlerInterface::class);

    $class_resolver = $this->prophesize(ClassResolverInterface::class);
    $class_resolver->getInstanceFromDefinition(Argument::type('string'))->will(function D$arguments) {
      $class_name = $arguments[0];
      return new $class_name();
    });

return;
        }

        if (!$response->isException()) {
            return;
        }

        $this->isInsideErrorHandlerLoop = true;

        // Get exception information         $error = new ArrayObject([], ArrayObject::ARRAY_AS_PROPS);
        $exceptions = $response->getException();
        $exception = $exceptions[0];
        $error->offsetSet('exception', $exception);

        // Keep a copy of the original request         $error->offsetSet('request', clone $request);

        // Get a count of the number of exceptions encountered         $this->exceptionCountAtFirstEncounter = \count($exceptions);

        // Forward to the error handler

    private function autowireMethod(\ReflectionFunctionAbstract $reflectionMethod, array $arguments, bool $checkAttributes, int $methodIndex): array
    {
        $class = $reflectionMethod instanceof \ReflectionMethod ? $reflectionMethod->class : $this->currentId;
        $method = $reflectionMethod->name;
        $parameters = $reflectionMethod->getParameters();
        if ($reflectionMethod->isVariadic()) {
            array_pop($parameters);
        }
        $this->defaultArgument->names = new \ArrayObject();

        foreach ($parameters as $index => $parameter) {
            $this->defaultArgument->names[$index] = $parameter->name;

            if (\array_key_exists($parameter->name, $arguments)) {
                $arguments[$index] = $arguments[$parameter->name];
                unset($arguments[$parameter->name]);
            }
            if (\array_key_exists($index, $arguments) && '' !== $arguments[$index]) {
                continue;
            }

  public function getAllRoutes() {
    $select = $this->connection->select($this->tableName, 'router')
      ->fields('router', ['name', 'route']);
    $routes = $select->execute()->fetchAllKeyed();

    $result = [];
    foreach ($routes as $name => $route) {
      $result[$name] = unserialize($route);
    }

    $array_object = new \ArrayObject($result);
    return $array_object->getIterator();
  }

  /** * {@inheritdoc} */
  public function reset() {
    $this->routes = [];
    $this->serializedRoutes = [];
    $this->cacheTagInvalidator->invalidateTags(['routes']);
  }

protected $definition;

  /** * {@inheritdoc} */
  protected function setUp(): void {
    parent::setUp();

    // getModuleAndPath() returns an array of the module name and directory.     [$module_name, $module_dir] = $this->getModuleAndPath();

    $namespaces = new \ArrayObject();
    $namespaces["Drupal\\$module_name"] = $module_dir . '/src';

    $module_handler = $this->createMock('Drupal\Core\Extension\ModuleHandlerInterface');
    $module_handler->expects($this->once())
      ->method('moduleExists')
      ->with($module_name)
      ->willReturn(TRUE);
    $typed_data_manager = $this->createMock(TypedDataManagerInterface::class);
    $plugin_manager = new FieldTypePluginManager(
      $namespaces,
      $this->createMock('Drupal\Core\Cache\CacheBackendInterface'),

/** * Tests that entity type labels use sentence-case. */
  public function testEntityLabelCasing() {
    $base_directory = $this->root . '/core/modules/';
    $modules = scandir($base_directory);
    $paths = [];
    foreach ($modules as $module) {
      $paths["\Drupal\\{$module}\Entity"] = $base_directory . $module . '/src/';
    }
    $namespaces = new \ArrayObject($paths);
    $discovery = new AnnotatedClassDiscovery('Entity', $namespaces, 'Drupal\Core\Entity\Annotation\EntityType');
    $definitions = $discovery->getDefinitions();

    foreach ($definitions as $definition) {
      /** @var \Drupal\Core\Entity\EntityType $definition */

      /** @var \Drupal\Core\StringTranslation\TranslatableMarkup $label */
      $label = $definition->getLabel();
      $collection_label = $definition->getCollectionLabel();

      $label_string = $label->getUntranslatedString();

if ($this->getMinimumCharge() || \count($this->View()->getAssign('sBasket')[CartKey::POSITIONS]) <= 0 || $this->View()->getAssign('sInvalidCartItems')) {
 $this->forward('cart');

 return;
 }

 $normalizer = $this->container->get('shopware.components.cart.proportional_cart_normalizer');
 $sOrderVariables = $this->View()->getAssign();
 $sOrderVariables['sBasketView'] = $sOrderVariables['sBasket'];
 $sOrderVariables['sBasket'] = $normalizer->normalize($sOrderVariables['sBasketView']);

 $this->session['sOrderVariables'] = new ArrayObject($sOrderVariables, ArrayObject::ARRAY_AS_PROPS);

 $agbChecked = $this->Request()->getParam('sAGB');
 if (!empty($agbChecked)) {
 $this->View()->assign('sAGBChecked', true);
 }

 $this->View()->assign('sTargetAction', 'confirm');

 $this->View()->assign('hasMixedArticles', $this->basketHasMixedProducts($this->View()->getAssign('sBasket')));
 $this->View()->assign('hasServiceArticles', $this->basketHasServiceProducts($this->View()->getAssign('sBasket')));

$markup = $markup->reveal();

 $items = [
 'will be escaped',
 $markup,
 ['#markup' => 'will be rendered'],
 ];
 $result = $this->systemUnderTest->safeJoin($twig_environment, $items, ' ');
 $this->assertEquals('will be escaped will be markup will be rendered', $result);

 // Ensure safe_join Twig filter supports Traversable variables. $items = new \ArrayObject([
 'will be escaped',
 $markup,
 ['#markup' => 'will be rendered'],
 ]);
 $result = $this->systemUnderTest->safeJoin($twig_environment, $items, ', ');
 $this->assertEquals('will be escaped, will be markup, will be rendered', $result);

 // Ensure safe_join Twig filter supports empty variables. $items = NULL;
 $result = $this->systemUnderTest->safeJoin($twig_environment, $items, ' ');
 $this->assertEmpty($result);
 }

  protected $entityTypeBundleInfo;

  /** * {@inheritdoc} */
  protected function setUp(): void {
    parent::setUp();

    $namespaces = new \ArrayObject([
      'Drupal\\Core\\TypedData' => $this->root . '/core/lib/Drupal/Core/TypedData',
      'Drupal\\Core\\Validation' => $this->root . '/core/lib/Drupal/Core/Validation',
      'Drupal\\Core\\Entity' => $this->root . '/core/lib/Drupal/Core/Entity',
    ]);
    $cache_backend = new NullBackend('cache');
    $module_handler = $this->prophesize(ModuleHandlerInterface::class);

    $class_resolver = $this->prophesize(ClassResolverInterface::class);
    $class_resolver->getInstanceFromDefinition(Argument::type('string'))->will(function D$arguments) {
      $class_name = $arguments[0];
      return new $class_name();
    });

$result[$key] = ['resource', get_resource_type($value)];
            } else {
                $result[$key] = ['string', (string) $value];
            }
        }

        return $result;
    }

    private function getClassNameFromIncomplete(\__PHP_Incomplete_Class $value): string
    {
        $array = new \ArrayObject($value);

        return $array['__PHP_Incomplete_Class_Name'];
    }

    public function getTraceAsString(): string
    {
        return $this->traceAsString;
    }

    /** * @return $this */

/** * {@inheritdoc} */
  protected function setUp(): void {
    parent::setUp();
    $this->viewsData = $this->getMockBuilder('Drupal\views\ViewsData')
      ->disableOriginalConstructor()
      ->getMock();
    $cache_backend = $this->createMock('Drupal\Core\Cache\CacheBackendInterface');
    $this->moduleHandler = $this->createMock('Drupal\Core\Extension\ModuleHandlerInterface');
    $this->handlerManager = new ViewsHandlerManager('test', new \ArrayObject([]), $this->viewsData, $cache_backend, $this->moduleHandler);
  }

  /** * Setups of the plugin factory. */
  protected function setupMockedFactory() {
    $this->factory = $this->createMock('Drupal\Component\Plugin\Factory\FactoryInterface');

    $reflection = new \ReflectionClass($this->handlerManager);
    $property = $reflection->getProperty('factory');
    $property->setValue($this->handlerManager, $this->factory);
  }

class InspectorTest extends TestCase {

  /** * Tests asserting argument is an array or traversable object. * * @covers ::assertTraversable */
  public function testAssertTraversable() {
    $this->assertTrue(Inspector::assertTraversable([]));
    $this->assertTrue(Inspector::assertTraversable(new \ArrayObject()));
    $this->assertFalse(Inspector::assertTraversable(new \stdClass()));
    $this->assertFalse(Inspector::assertTraversable('foo'));
  }

  /** * Tests asserting all members are strings. * * @covers ::assertAllStrings * @dataProvider providerTestAssertAllStrings */
  public function testAssertAllStrings($input, $expected) {

        /** @var BasketPersister $persister */
        $persister = $this->get('basket_persister');
        $data = $persister->load($signature);

        if (!$data) {
            throw new RuntimeException(sprintf('Basket for signature %s not found', $signature));
        }

        $persister->delete($signature);

        $basket = new ArrayObject($data, ArrayObject::ARRAY_AS_PROPS);
        $this->get('session')->offsetSet('sOrderVariables', $basket);

        return $basket;
    }

    /** * Used by payment plugins * * @param string $signature * * @throws RuntimeException if signature does not match with provided basket */