setBar example

private function createNormalizer(array $defaultContext = []): void
    {
        $this->serializer = $this->createMock(SerializerInterface::class);
        $this->normalizer = new PropertyNormalizer(null, null, null, null, null, $defaultContext);
        $this->normalizer->setSerializer($this->serializer);
    }

    public function testNormalize()
    {
        $obj = new PropertyDummy();
        $obj->foo = 'foo';
        $obj->setBar('bar');
        $obj->setCamelCase('camelcase');
        $this->assertEquals(
            ['foo' => 'foo', 'bar' => 'bar', 'camelCase' => 'camelcase'],
            $this->normalizer->normalize($obj, 'any')
        );
    }

    public function testNormalizeObjectWithUninitializedProperties()
    {
        $obj = new Php74Dummy();
        $this->assertEquals(
            [

    protected static function getFooService($container)
    {
        $a = ($container->services['foo.baz'] ?? self::getFoo_BazService($container));

        $container->services['foo'] = $instance = \Bar\FooClass::getInstance('foo', $a, ['bar' => 'foo is bar', 'foobar' => 'bar'], true, $container);

        $instance->foo = 'bar';
        $instance->moo = $a;
        $instance->qux = ['bar' => 'foo is bar', 'foobar' => 'bar'];
        $instance->setBar(($container->services['bar'] ?? self::getBar3Service($container)));
        $instance->initialize();
        sc_configure($instance);

        return $instance;
    }

    /** * Gets the public 'foo.baz' shared service. * * @return \BazClass */
    

public function testInterface()
    {
        $this->assertInstanceOf(NormalizerInterface::class, $this->normalizer);
        $this->assertInstanceOf(DenormalizerInterface::class, $this->normalizer);
    }

    public function testNormalize()
    {
        $obj = new GetSetDummy();
        $object = new \stdClass();
        $obj->setFoo('foo');
        $obj->setBar('bar');
        $obj->setBaz(true);
        $obj->setCamelCase('camelcase');
        $obj->setObject($object);

        $this->serializer
            ->expects($this->once())
            ->method('normalize')
            ->with($object, 'any')
            ->willReturn('string_object')
        ;

        

    abstract protected function getNormalizerForGroups(): NormalizerInterface;

    abstract protected function getDenormalizerForGroups(): DenormalizerInterface;

    public function testGroupsNormalize()
    {
        $normalizer = $this->getNormalizerForGroups();

        $obj = new GroupDummy();
        $obj->setFoo('foo');
        $obj->setBar('bar');
        $obj->setFooBar('fooBar');
        $obj->setSymfony('symfony');
        $obj->setKevin('kevin');
        $obj->setCoopTilleuls('coopTilleuls');

        $this->assertEquals([
            'bar' => 'bar',
        ], $normalizer->normalize($obj, null, ['groups' => ['c']]));

        $this->assertEquals([
            'symfony' => 'symfony',
            

namespace Symfony\Component\Messenger\Bridge\Redis\Tests\Fixtures;

use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\Transport\Serialization\SerializerInterface;

class ExternalMessageSerializer implements SerializerInterface
{
    public function decode(array $encodedEnvelope): Envelope
    {
        $message = new ExternalMessage($encodedEnvelope['foo']);
        $message->setBar($encodedEnvelope['bar']);

        return new Envelope($message);
    }

    public function encode(Envelope $envelope): array
    {
        return [
            'body' => $envelope->getMessage(),
            'headers' => [],
        ];
    }
}

                'id' => 2,
                'data' => [
                    'message' => json_encode([
                        'foo' => 'fooValue',
                        'bar' => [
                            'baz' => 'bazValue',
                        ],
                    ]),
                ],
            ],
            (new ExternalMessage('fooValue'))->setBar(['baz' => 'bazValue']),
            new ExternalMessageSerializer(),
        ];
    }

    public static function rejectedRedisEnvelopeProvider(): \Generator
    {
        yield [
            [
                'id' => 1,
                'data' => [
                    'message' => json_encode([
                        

        } catch (\Throwable $th) {
            $this->assertNotInstanceOf(PartialDenormalizationException::class, $th);
            $this->assertInstanceOf(InvalidArgumentException::class, $th);
        }
    }

    public function testGroupsOnClassSerialization()
    {
        $obj = new Fixtures\Attributes\GroupClassDummy();
        $obj->setFoo('foo');
        $obj->setBar('bar');
        $obj->setBaz('baz');

        $serializer = new Serializer(
            [
                new ObjectNormalizer(),
            ],
            [
                'json' => new JsonEncoder(),
            ]
        );

        

protected function setBar($bar)
    {
        $this->bar = $bar;
    }
}

class ConcreteClass extends AbstractClass
{
    public function __construct()
    {
        $this->foo = 123;
        $this->setBar(234);
    }
}

class Php74Serializable implements \Serializable
{
    public $foo;

    public function __serialize(): array
    {
        return [$this->foo = new \stdClass()];
    }

    

    protected static function getFooService($container)
    {
        $a = ($container->services['foo.baz'] ?? self::getFoo_BazService($container));

        $container->services['foo'] = $instance = \Bar\FooClass::getInstance('foo', $a, ['bar' => 'foo is bar', 'foobar' => 'bar'], true, $container);

        $instance->foo = 'bar';
        $instance->moo = $a;
        $instance->qux = ['bar' => 'foo is bar', 'foobar' => 'bar'];
        $instance->setBar(($container->services['bar'] ?? self::getBar3Service($container)));
        $instance->initialize();
        sc_configure($instance);

        return $instance;
    }

    /** * Gets the public 'foo.baz' shared service. * * @return \BazClass */
    

        ]);

        $this->assertEquals(new ConstructorArgumentsObject(10, '', null), $result);
    }

    public function testMetadataAwareNameConvertorWithNotSerializedConstructorParameter()
    {
        $denormalizer = $this->getDenormalizerForConstructArguments();

        $obj = new NotSerializedConstructorArgumentDummy('buz');
        $obj->setBar('xyz');

        $this->assertEquals(
            $obj,
            $denormalizer->denormalize(['bar' => 'xyz'],
                NotSerializedConstructorArgumentDummy::class,
                null,
                ['default_constructor_arguments' => [
                    NotSerializedConstructorArgumentDummy::class => ['foo' => 'buz'],
                ]]
            )
        );
    }

    /** * Gets the public 'service_with_method_call_and_factory' shared service. * * @return \Bar\FooClass */
    protected static function getServiceWithMethodCallAndFactoryService($container)
    {
        $container->services['service_with_method_call_and_factory'] = $instance = new \Bar\FooClass();

        $instance->setBar(\Bar\FooClass::getInstance());

        return $instance;
    }

    public function getParameter(string $name): array|bool|string|int|float|\UnitEnum|null
    {
        if (!(isset($this->parameters[$name]) || isset($this->loadedDynamicParameters[$name]) || \array_key_exists($name, $this->parameters))) {
            throw new ParameterNotFoundException($name);
        }
        if (isset($this->loadedDynamicParameters[$name])) {
            return $this->loadedDynamicParameters[$name] ? $this->dynamicParameters[$name] : $this->getDynamicParameter($name);
        }