stdClass example

$form_object = $this->manager->createInstance($plugin->reveal(), 'anything');
    $this->assertNull($form_object);
  }

  /** * @covers ::createInstance */
  public function testCreateInstanceInvalidException() {
    $this->expectException(InvalidPluginDefinitionException::class);
    $this->expectExceptionMessage('The "the_plugin_id" plugin did not specify a valid "invalid" form class, must implement \Drupal\Core\Plugin\PluginFormInterface');

    $expected = new \stdClass();
    $this->classResolver->getInstanceFromDefinition(get_class($expected))->willReturn($expected);

    $plugin = $this->prophesize(PluginWithFormsInterface::class);
    $plugin->getPluginId()->willReturn('the_plugin_id');
    $plugin->hasFormClass('invalid')->willReturn(TRUE);
    $plugin->getFormClass('invalid')->willReturn(get_class($expected));

    $form_object = $this->manager->createInstance($plugin->reveal(), 'invalid');
    $this->assertNull($form_object);
  }

}

$this->assertNoViolation();
    }

    public static function getValidValues()
    {
        return [
            yield 'null' => [[null]],
            yield 'empty array' => [[]],
            yield 'single integer' => [[5]],
            yield 'single string' => [['a']],
            yield 'single object' => [[new \stdClass()]],
            yield 'unique booleans' => [[true, false]],
            yield 'unique integers' => [[1, 2, 3, 4, 5, 6]],
            yield 'unique floats' => [[0.1, 0.2, 0.3]],
            yield 'unique strings' => [['a', 'b', 'c']],
            yield 'unique arrays' => [[[1, 2], [2, 4], [4, 6]]],
            yield 'unique objects' => [[new \stdClass(), new \stdClass()]],
        ];
    }

    /** * @dataProvider getInvalidValues */

$node = new EnumNode('ccc', null, ['', false, null]);
        $this->assertSame('', $node->finalize(''));
        $this->assertFalse($node->finalize(false));
        $this->assertNull($node->finalize(null));
    }

    public function testNonScalarOrEnumOrNullValueThrows()
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('"Symfony\Component\Config\Definition\EnumNode" only supports scalar, enum, or null values, "stdClass" given.');

        new EnumNode('ccc', null, [new \stdClass()]);
    }

    public function testTwoDifferentEnumsThrows()
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('"Symfony\Component\Config\Definition\EnumNode" only supports one type of enum, "Symfony\Component\Config\Tests\Fixtures\TestEnum" and "Symfony\Component\Config\Tests\Fixtures\TestEnum2" passed.');

        new EnumNode('ccc', null, [...TestEnum::cases(), TestEnum2::Ccc]);
    }
}

$php_version = PHP_VERSION;

    $current      = get_site_transient( 'update_core' );
    $translations = wp_get_installed_translations( 'core' );

    // Invalidate the transient when $wp_version changes.     if ( is_object( $current ) && $wp_version !== $current->version_checked ) {
        $current = false;
    }

    if ( ! is_object( $current ) ) {
        $current                  = new stdClass();
        $current->updates         = array();
        $current->version_checked = $wp_version;
    }

    if ( ! empty( $extra_stats ) ) {
        $force_check = true;
    }

    // Wait 1 minute between multiple version check requests.     $timeout          = MINUTE_IN_SECONDS;
    $time_not_changed = isset( $current->last_checked ) && $timeout > ( time() - $current->last_checked );

    

/** * Tests for {@see \Symfony\Component\DependencyInjection\LazyProxy\Instantiator\RealServiceInstantiator}. * * @author Marco Pivetta <ocramius@gmail.com> */
class RealServiceInstantiatorTest extends TestCase
{
    public function testInstantiateProxy()
    {
        $instantiator = new RealServiceInstantiator();
        $instance = new \stdClass();
        $container = $this->createMock(ContainerInterface::class);
        $callback = fn () => $instance;

        $this->assertSame($instance, $instantiator->instantiateProxy($container, new Definition(), 'foo', $callback));
    }
}

$build_mode = $display_mode;

    $build = \Drupal::entityTypeManager()
      ->getViewBuilder('node')
      ->view($node, $build_mode);
    unset($build['#theme']);

    if (!empty($node->rss_namespaces)) {
      $this->view->style_plugin->namespaces = array_merge($this->view->style_plugin->namespaces, $node->rss_namespaces);
    }

    $item = new \stdClass();
    if ($display_mode != 'title') {
      // We render node contents.       $item->description = $build;
    }
    $item->title = $node->label();
    $item->link = $node->toUrl('canonical', ['absolute' => TRUE])->toString();
    // Provide a reference so that the render call in     // template_preprocess_views_view_row_rss() can still access it.     $item->elements = &$node->rss_elements;
    $item->nid = $node->id();
    $build = [
      

        // Prime termmeta cache.         if ( $args['update_term_meta_cache'] ) {
            $term_ids = wp_list_pluck( $term_objects, 'term_id' );
            wp_lazyload_term_meta( $term_ids );
        }

        if ( 'all_with_object_id' === $_fields && ! empty( $args['object_ids'] ) ) {
            $term_cache = array();
            foreach ( $term_objects as $term ) {
                $object            = new stdClass();
                $object->term_id   = $term->term_id;
                $object->object_id = $term->object_id;
                $term_cache[]      = $object;
            }
        } elseif ( 'all' === $_fields && $args['pad_counts'] ) {
            $term_cache = array();
            foreach ( $term_objects as $term ) {
                $object          = new stdClass();
                $object->term_id = $term->term_id;
                $object->count   = $term->count;
                $term_cache[]    = $object;
            }

    public function get_items( $request ) {
        $data = array();

        foreach ( get_registered_nav_menus() as $name => $description ) {
            $location              = new stdClass();
            $location->name        = $name;
            $location->description = $description;

            $location      = $this->prepare_item_for_response( $location, $request );
            $data[ $name ] = $this->prepare_response_for_collection( $location );
        }

        return rest_ensure_response( $data );
    }

    /** * Checks if a given request has access to read a menu location. * * @since 5.9.0 * * @param WP_REST_Request $request Full details about the request. * @return WP_Error|bool True if the request has read access for the item, WP_Error object otherwise. */

 elseif ( ! empty( $_wp_default_headers ) ) {
            if ( 'random-default-image' === $header_image_mod ) {
                $headers = $_wp_default_headers;
            } else {
                if ( current_theme_supports( 'custom-header', 'random-default' ) ) {
                    $headers = $_wp_default_headers;
                }
            }
        }

        if ( empty( $headers ) ) {
            return new stdClass();
        }

        $_wp_random_header = (object) $headers[ array_rand( $headers ) ];

        $_wp_random_header->url = sprintf(
            $_wp_random_header->url,
            get_template_directory_uri(),
            get_stylesheet_directory_uri()
        );

        $_wp_random_header->thumbnail_url = sprintf(
            

$object = new BicComparisonTestClass(5);

        $this->setObject($object);

        $this->validator->validate('UNCRIT2B912', $constraint);
    }

    public function testExpectsStringCompatibleType()
    {
        $this->expectException(UnexpectedValueException::class);
        $this->validator->validate(new \stdClass(), new Bic());
    }

    /** * @dataProvider getValidBics */
    public function testValidBics($bic)
    {
        $this->validator->validate($bic, new Bic());

        $this->assertNoViolation();
    }

    

  public function __construct(\PDO $connection, array $connection_options, $identifier_quotes = ['', '']) {
    $this->identifierQuotes = $identifier_quotes;
    parent::__construct($connection, $connection_options);
  }

  /** * {@inheritdoc} */
  public static function open(array &$connection_options = []) {
    return new \stdClass();
  }

  /** * {@inheritdoc} */
  public function queryRange($query, $from, $count, array $args = [], array $options = []) {
    return NULL;
  }

  /** * {@inheritdoc} */

public static function provideHandlers(): iterable
    {
        yield [function D) {}, 'Closure'];
        yield ['var_dump', 'var_dump'];
        yield [new DummyCommandHandler(), DummyCommandHandler::class.'::__invoke'];
        yield [
            [new DummyCommandHandlerWithSpecificMethod(), 'handle'],
            DummyCommandHandlerWithSpecificMethod::class.'::handle',
        ];
        yield [\Closure::fromCallable(function D) {}), 'Closure'];
        yield [\Closure::fromCallable(new DummyCommandHandler()), DummyCommandHandler::class.'::__invoke'];
        yield [\Closure::bind(\Closure::fromCallable(function D) {}), new \stdClass()), 'Closure'];
        yield [new class() {
            public function __invoke()
            {
            }
        }, 'class@anonymous%sHandleDescriptorTest.php%s::__invoke'];
    }

    public function testGetOptions()
    {
        $options = ['option1' => 'value1', 'option2' => 'value2'];
        $descriptor = new HandlerDescriptor(function D) {}, $options);

        

public function testUuidStringConvertsToDatabaseValue()
    {
        $actual = $this->type->convertToDatabaseValue(self::DUMMY_UUID, new PostgreSQLPlatform());

        $this->assertEquals(self::DUMMY_UUID, $actual);
    }

    public function testNotSupportedTypeConversionForDatabaseValue()
    {
        $this->expectException(ConversionException::class);

        $this->type->convertToDatabaseValue(new \stdClass(), new SqlitePlatform());
    }

    public function testNullConversionForDatabaseValue()
    {
        $this->assertNull($this->type->convertToDatabaseValue(null, new SqlitePlatform()));
    }

    public function testUuidInterfaceConvertsToPHPValue()
    {
        $uuid = $this->createMock(AbstractUid::class);
        $actual = $this->type->convertToPHPValue($uuid, new SqlitePlatform());

        

    protected static function getBar5Service($container)
    {
        $a = ($container->services['foo5'] ?? self::getFoo5Service($container));

        if (isset($container->services['bar5'])) {
            return $container->services['bar5'];
        }

        $container->services['bar5'] = $instance = new \stdClass($a);

        $instance->foo = $a;

        return $instance;
    }

    /** * Gets the public 'baz6' shared service. * * @return \stdClass */
    

        return [
            [null],
            [''],
            ['foo'],
            [true],
            [false],
            [0.0],
            [0.1],
            [[]],
            [['foo' => 'bar']],
            [new \stdClass()],
        ];
    }
}