public function testCustomSubscribingHandler()
 {
     $fixture = file_get_contents(FIXTURE_ROOT . '/Unit/Serializer/JmsSerializer/test_entity_1.json');
     $resultEntity = $this->realJms->deserialize($fixture, 'Elastification\\Client\\Serializer\\JmsSerializer\\SearchResponseEntity', 'json');
     $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\SearchResponseEntity', $resultEntity);
     /* @var $resultEntity \Elastification\Client\Serializer\JmsSerializer\SearchResponseEntity */
     $this->assertEquals(1, $resultEntity->took);
     $this->assertEquals(false, $resultEntity->timed_out);
     $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\Shards', $resultEntity->_shards);
     $this->assertEquals(1, $resultEntity->_shards->total);
     $this->assertEquals(1, $resultEntity->_shards->successful);
     $this->assertEquals(0, $resultEntity->_shards->failed);
     $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\Hits', $resultEntity->hits);
     $this->assertEquals(1, $resultEntity->hits->total);
     $this->assertEquals(0, $resultEntity->hits->maxScore);
     $this->assertCount(1, $resultEntity->hits->hits);
     $hit = $resultEntity->hits->hits[0];
     $this->assertInstanceOf('Elastification\\Client\\Serializer\\JmsSerializer\\Hit', $hit);
     $this->assertEquals('4372-4412104-928-DL', $hit->_id);
     $this->assertEquals('elastification', $hit->_index);
     $this->assertEquals('test', $hit->_type);
     $this->assertEquals(1.993935, $hit->_score);
     $entity = $hit->_source;
     $this->assertInstanceOf('Elastification\\Client\\Tests\\Fixtures\\Unit\\Serializer\\JmsSerializer\\TestEntity', $entity);
     $this->assertEquals(123, $entity->a);
 }

 /**
  * @param array      $data
  * @param Serializer $serializer
  * @return LegalEntity
  * @throws \Exception
  */
 public static function create(array $data, Serializer $serializer)
 {
     $caseType = null;
     $data['caseType'] = isset($data['caseType']) ? $data['caseType'] : 'Lpa';
     if (!empty($data['caseType'])) {
         switch ($data['caseType']) {
             case "Epa":
                 $caseType = "Opg\\Core\\Model\\Entity\\CaseItem\\PowerOfAttorney\\Epa";
                 break;
             case "Order":
                 $caseType = "Opg\\Core\\Model\\Entity\\CaseItem\\Deputyship\\Order";
                 break;
             default:
                 $caseType = "Opg\\Core\\Model\\Entity\\CaseItem\\PowerOfAttorney\\Lpa";
                 break;
         }
     } else {
         throw new \Exception('Cannot build unknown case type.');
     }
     try {
         /** @var CaseItem $case */
         $case = $serializer->deserialize(json_encode($data), $caseType, 'json');
     } catch (\Exception $e) {
         throw $e;
     }
     return $case;
 }

 protected function setUp()
 {
     $this->channel = $this->prophesize(AMQPChannel::class);
     $this->serializer = $this->prophesize(Serializer::class);
     $this->eventDispatcher = $this->prophesize(EventDispatcherInterface::class);
     $this->parser = $this->prophesize(Parser::class);
     $this->manager = new ConsumerManager($this->channel->reveal(), self::EXCHANGE_NAME, $this->serializer->reveal(), $this->parser->reveal());
     $this->manager->setEventDispatcher($this->eventDispatcher->reveal());
 }

 /**
  * @param \Doctrine\ORM\Event\LifecycleEventArgs $args
  */
 public function postPersist(LifecycleEventArgs $args)
 {
     $layoutBlock = $args->getEntity();
     if ($layoutBlock instanceof LayoutBlock) {
         if ($contentObject = $layoutBlock->getSnapshotContent()) {
             $contentObject = $this->serializer->deserialize($contentObject, $layoutBlock->getClassType(), 'json');
             $em = $args->getEntityManager();
             try {
                 $em->persist($contentObject);
                 $contentObject = $em->merge($contentObject);
                 $reflection = new \ReflectionClass($contentObject);
                 foreach ($reflection->getProperties() as $property) {
                     $method = sprintf('get%s', ucfirst($property->getName()));
                     if ($reflection->hasMethod($method) && ($var = $contentObject->{$method}())) {
                         if ($var instanceof ArrayCollection) {
                             foreach ($var as $v) {
                                 $em->merge($v);
                             }
                         }
                     }
                 }
             } catch (EntityNotFoundException $e) {
                 $em->detach($contentObject);
                 $classType = $layoutBlock->getClassType();
                 $contentObject = new $classType();
                 $em->persist($contentObject);
             }
             $em->flush($contentObject);
             $layoutBlock->setObjectId($contentObject->getId());
             $em->persist($layoutBlock);
             $em->flush($layoutBlock);
         }
     }
 }

 /**
  * @param GetResponseForControllerResultEvent $event
  */
 public function serializeResponse(GetResponseForControllerResultEvent $event)
 {
     if ($this->doSerialize) {
         $data = $event->getControllerResult();
         $apiResponse = new ApiResponse(200, $data);
         $data = array_merge($apiResponse->toArray(), $this->data->all());
         $data = array_filter($data);
         if (!isset($data['data'])) {
             $data['data'] = [];
         }
         $context = new SerializationContext();
         $context->setSerializeNull(true);
         if (method_exists($context, 'enableMaxDepthChecks')) {
             $context->enableMaxDepthChecks();
         }
         if ($action = $this->getAction($event)) {
             $context->setGroups($action->getSerializationGroups());
         }
         if ($fields = $event->getRequest()->query->get('fields')) {
             $context->addExclusionStrategy(new FieldsListExclusionStrategy($fields));
         }
         $json = $this->serializer->serialize($data, 'json', $context);
         $response = new Response($json, 200, ['Content-Type' => 'application/json']);
         $event->setResponse($response);
         $event->stopPropagation();
     }
 }

 public function put($resource, $body, $type, $options = [])
 {
     $options['body'] = $this->serializer->serialize($body, 'json');
     $options['headers'] = ['Content-Type' => 'application/json'];
     $content = $this->client->put($resource, $options)->getBody()->getContents();
     return $this->deserialize($content, $type);
 }

 /**
  * @param mixed $object
  * @return array
  */
 public function unmapObject($object)
 {
     if (is_array($object)) {
         return $object;
     }
     return $this->serializer->toArray($object);
 }

 public function testDeserializeJson()
 {
     $json = '{"foo":"bar","baz":[1,2,3]}';
     /** @var Metadata $metadata */
     $metadata = $this->serializer->deserialize($json, Metadata::class, 'json');
     $this->assertInstanceOf(Metadata::class, $metadata);
     $this->assertEquals(['baz' => [1, 2, 3], 'foo' => 'bar'], $metadata->toArray());
 }

 /**
  * @param InputInterface  $input
  * @param OutputInterface $output
  *
  * @return bool
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     foreach ($this->sources as $name => $class) {
         $result = $this->serializer->deserialize(file_get_contents(getcwd() . '/tests/Common/Api/test_cases/protocols/output/fixtures/' . $name . '.xml'), $class, 'xml');
         file_put_contents(getcwd() . '/tests/Common/Api/test_cases/protocols/output/fixtures/' . $name . '.serialized', serialize($result->getBody()));
         $output->writeln('Processed ' . $name . ' serialized file.');
     }
 }

 /**
  * Render the view into a string and return for output
  *
  * @param mixed $input
  * @return string
  * @throws \Exception
  */
 public function render($input = null)
 {
     $context = new SerializationContext();
     $context->setSerializeNull(true);
     $context->enableMaxDepthChecks();
     FrontController::getInstance()->getResponse()->headers->set('Content-Type', 'application/json');
     return $this->serializer->serialize($input, $this->format, $context);
 }

 /**
  * @param ServiceEvent $event
  */
 public function onResponseEvent(ServiceEvent $event)
 {
     $service = $event->getService();
     if ($service instanceof ServiceConfigurableInterface && null !== $service->getOption('response_type')) {
         /** @var Service $service */
         $service->getResponse()->setDeserializedContent($this->serializer->deserialize($service->getResponse()->getContent(), $service->getOption('response_type'), $service->getOption('response_format')));
     }
 }

 public function json($data, $groups = null)
 {
     if ($groups) {
         $this->context->setGroups($groups);
     }
     $serializedData = $this->serializer->serialize($data, 'json', $this->context);
     return $serializedData;
 }

 /**
  * @param AbstractJsonEvent $event
  * 
  * @return AbstractJsonEvent
  */
 public function deserialize(AbstractJsonEvent $event)
 {
     $deSerialized = $this->serializer->deserialize($event->getJson(), get_class($event), self::JSON_FORMAT);
     $deSerialized->type = $event->type;
     $deSerialized->content = $event->content;
     $deSerialized->setName($event->getName());
     return $deSerialized;
 }

 /**
  * Deserializes request content.
  *
  * @param ResponseInterface $response
  * @param string            $type
  * @param string            $format
  *
  * @return mixed
  *
  * @throws \Exception
  */
 protected function deserialize(ResponseInterface $response, $type, $format = 'json')
 {
     try {
         return $this->serializer->deserialize((string) $response->getBody(), $type, $format);
     } catch (\Exception $exception) {
         $this->logger->error('[WebServiceClient] Deserialization problem on webservice call.', array('response' => (string) $response->getBody(), 'exception' => $exception));
         throw $exception;
     }
 }

 public function testDeserializeJson()
 {
     $json = '{"uuid":"ed34c88e-78b0-11e3-9ade-406c8f20ad00"}';
     /** @var ObjectWithUuid $object */
     $object = $this->serializer->deserialize($json, ObjectWithUuid::class, 'json');
     $uuid = $object->getUuid();
     $this->assertInstanceOf(UuidInterface::class, $uuid);
     $this->assertEquals('ed34c88e-78b0-11e3-9ade-406c8f20ad00', (string) $uuid);
 }

 /**
  * @inheritDoc
  */
 public function getResponse($responseType, $view, $templateName, $params, $status = 200, $headers = [], $groups = ['Default'])
 {
     if ($responseType === 'html') {
         $response = $this->getHtml($view, $templateName, $params);
     } else {
         $response = $this->serializer->serialize($params, $responseType, SerializationContext::create()->setGroups($groups));
     }
     return new Response($response, $status, $headers);
 }

 /**
  * @test
  */
 public function it_can_be_deserialized()
 {
     $modelData = $this->getModelData();
     $modelClass = $this->getModelClass();
     /** @var AbstractModel $model */
     $model = $this->serializer->deserialize(json_encode($modelData), $modelClass, 'json');
     $this->assertInstanceOf($modelClass, $model);
     $this->assertInstanceOf('CL\\Slack\\Model\\AbstractModel', $model);
     $this->assertModel($modelData, $model);
 }

 /**
  * @param $data
  * @param $entityName
  * @return mixed
  */
 public function hydrateEntity($data, $entityName)
 {
     if (empty($data)) {
         $data = array();
     }
     if (is_string($data)) {
         $data = json_decode($data, true);
     }
     return $this->serializer->deserialize(json_encode($this->transformer->transformHydrateData($data)), $entityName, 'json');
 }

 public function put($resource, $body, $type, $options = [])
 {
     $options['future'] = true;
     $options['body'] = $this->serializer->serialize($body, 'json');
     $options['headers'] = ['Content-Type' => 'application/json'];
     return $this->client->put($resource, $options)->then(function (Response $reponse) {
         return $reponse->getBody()->getContents();
     })->then(function ($content) use($type) {
         return $this->deserialize($content, $type);
     });
 }

 /**
  * @param array|object $data
  * @param string $dtoClassName
  * @param string $outputFormat
  * @return array
  */
 public function serialize($data, $dtoClassName, $outputFormat = 'json')
 {
     // TODO: check if $data is object or array
     $itemArray = [];
     foreach ($data as $item) {
         $dto = $this->shifter->toDto($item, new $dtoClassName());
         $serializedData = $this->serializer->serialize($dto, $outputFormat);
         $itemArray[] = (array) json_decode($serializedData);
     }
     return $itemArray;
 }