public function testClassDeviceResult() { $class = new \ReflectionClass('UAParser\\Result\\Device'); $this->assertTrue($class->hasProperty('model'), 'property family does not exist anymore'); $this->assertTrue($class->hasProperty('brand'), 'property major does not exist anymore'); $this->assertTrue($class->hasProperty('family'), 'property family does not exist anymore'); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { foreach ($container->findTaggedServiceIds('mautic.event_subscriber') as $id => $tags) { $definition = $container->findDefinition($id); $classParents = class_parents($definition->getClass()); if (!in_array(CommonSubscriber::class, $classParents)) { continue; } $definition->addMethodCall('setTemplating', [new Reference('mautic.helper.templating')]); $definition->addMethodCall('setRequest', [new Reference('request_stack')]); $definition->addMethodCall('setSecurity', [new Reference('mautic.security')]); $definition->addMethodCall('setSerializer', [new Reference('jms_serializer')]); $definition->addMethodCall('setSystemParameters', [new Parameter('mautic.parameters')]); $definition->addMethodCall('setDispatcher', [new Reference('event_dispatcher')]); $definition->addMethodCall('setTranslator', [new Reference('translator')]); $definition->addMethodCall('setEntityManager', [new Reference('doctrine.orm.entity_manager')]); $definition->addMethodCall('setRouter', [new Reference('router')]); $class = $definition->getClass(); $reflected = new \ReflectionClass($class); if ($reflected->hasProperty('logger')) { $definition->addMethodCall('setLogger', [new Reference('monolog.logger.mautic')]); } // Temporary, for development purposes if ($reflected->hasProperty('factory')) { $definition->addMethodCall('setFactory', [new Reference('mautic.factory')]); } if (in_array(WebhookSubscriberBase::class, $classParents)) { $definition->addMethodCall('setWebhookModel', [new Reference('mautic.webhook.model.webhook')]); } $definition->addMethodCall('init'); } }
/** * Magic function which handles the properties accessibility. * @param string $propertyName The property name. */ public function __get($propertyName) { switch ($propertyName) { case '_baseExtendableObject': return $this->_baseExtendableObject; default: $class = new \ReflectionClass($this); if ($class->hasProperty($propertyName)) { $property = $class->getProperty($propertyName); $property->setAccessible(true); return $property->getValue($this); } else { if ($class->hasProperty('_' . $propertyName)) { $property = $class->getProperty('_' . $propertyName); $property->setAccessible(true); return $property->getValue($this); } else { $baseClass = new \ReflectionClass($_baseExtendableObject); $method = $baseClass->getMethod('__get'); return $method->invoke($this, $propertyName); } } return null; } }
/** */ public function testAddProperty() { $prop = new ReflectionProperty('test'); $this->assertFalse($this->object->hasProperty('test')); $this->object->addProperty($prop); $this->assertTrue($this->object->hasProperty('test')); }
public function testContracts() { $this->assertTrue($this->reflectedObject->isAbstract()); $this->assertTrue($this->reflectedObject->hasMethod('getDefaultConfig')); $this->assertTrue($this->reflectedObject->hasProperty('ts')); $this->assertTrue($this->reflectedObject->hasProperty('shortcodes')); $this->assertTrue($this->reflectedObject->hasProperty('config')); }
protected function getProperty($name) { if (!$this->target->hasProperty($name)) { $message = sprintf('Property not found on object %s.', get_class($this->origin)); throw new OutOfBoundsException($message); } /** @var ReflectionProperty $property */ $property = $this->target->getProperty($name); $property->setAccessible(true); return $property; }
/** * Adds the name of the specified hook to $hooks using reflection. * @param $class_name */ private function add_hook_reflect($class_name) { $reflector = new ReflectionClass($class_name); if (!$reflector->isAbstract() && $reflector->isSubclassOf("Hook") && $class_name !== "GenericHook" && $reflector->hasProperty("friendly_name")) { $instance = $reflector->newInstance(); $name = $reflector->getProperty("friendly_name")->getValue($instance); $this->hooks[$name] = ""; if ($this->get_config("Main", "web_hooks") && $reflector->hasProperty("web") && $reflector->getProperty("web")->getValue($instance)) { $this->web_hooks[$name] = ""; } } }
/** * @param $property_name * @param $name * @return \Symforce\CoreBundle\Annotation\SymforceAbstractAnnotation|array * @throws \Exception */ public function getPropertyValue($property_name, $name, $fetch_values = false) { if (!$this->reflection->hasProperty($property_name)) { throw new \Exception(sprintf("class property(%s->%s) not exists in file: %s ", $this->name, $property_name, $this->reflection->getFileName())); } if (!isset($this->properties_annotations[$property_name][$name])) { throw new \Exception(); } if ($fetch_values) { $this->properties_annotations[$property_name][$name]->values; } return $this->properties_annotations[$property_name][$name]->value; }
public function __construct($data = NULL) { if (!is_null($data) && !is_numeric($data) && !is_array($data) && !$data instanceof stdClass) { throw new ShopException('Invalid $data type'); } if (is_array($data) || $data instanceof stdClass) { $this->loadFromArray((array) $data); } /** * Look for Item repository. * For IDE purposes like code completion $this->repo's type should be hinted in each Item the way I did in Cart. */ $repoClass = $this->getRepo(); $reflection = new ReflectionClass($repoClass); $repoClass = (string) $reflection->getName(); $this->repo = $reflection->isInstantiable() ? new $repoClass() : null; /** * Look for srl field if it's not already set in class $meta */ $reflection = new ReflectionClass($this); if ($srlField = $this->getMeta('srl')) { //if srl is given if (!$reflection->hasProperty($srlField)) { throw new ShopException("Srl field '{$srlField}' doesn't exist"); } } elseif ($reflection->hasProperty('srl')) { $this->setMeta('srl', 'srl'); } else { //else return the first _srl field foreach ($this as $field => $value) { if (substr($field, strlen($field) - 4, strlen($field)) === '_srl') { $this->setMeta('srl', $field); break; } } if (!$this->getMeta('srl')) { throw new ShopException('Couldn\'t identify the _srl column'); } } //data can also be a serial if (is_numeric($data)) { if ($obj = $this->repo->get($data, "get%E", get_called_class())) { $this->copy($obj); } else { throw new ShopException("No such {$this->repo->entity} srl {$data}"); } } if (is_null(self::$cache)) { self::$cache = new ShopCache(); } }
public function __toString() { $object = new \ReflectionClass($this); // Get the name of the constant type $type = array_search($this->getType(), $object->getConstants()); // SimpleToken if ($object->hasProperty('value')) { return sprintf('Token: %s Value: %s', $type, $this->getValue()); } elseif ($object->hasProperty('name')) { return sprintf('Token: %s Namespace: %s Name: %s', $type, $this->getNamespace(), $this->getName()); } else { return sprintf('Token: %s', $type); } }
/** * Casts objects to arrays and adds the dynamic property prefix. * * @param object $obj The object to cast * @param \ReflectionClass $reflector The class reflector to use for inspecting the object definition * * @return array The array-cast of the object, with prefixed dynamic properties */ public static function castObject($obj, \ReflectionClass $reflector) { if ($reflector->hasMethod('__debugInfo')) { $a = $obj->__debugInfo(); } elseif ($obj instanceof \Closure) { $a = array(); } else { $a = (array) $obj; } if ($obj instanceof \__PHP_Incomplete_Class) { return $a; } if ($a) { $combine = false; $p = array_keys($a); foreach ($p as $i => $k) { if (isset($k[0]) && "" !== $k[0] && !$reflector->hasProperty($k)) { $combine = true; $p[$i] = self::PREFIX_DYNAMIC . $k; } elseif (isset($k[16]) && "" === $k[16] && 0 === strpos($k, "class@anonymous")) { $combine = true; $p[$i] = "" . $reflector->getParentClass() . '@anonymous' . strrchr($k, ""); } } if ($combine) { $a = array_combine($p, $a); } } return $a; }
/** * Este escucha permite esteblecer el consecutivo de las entidades * al momento de ser almacenadas en base de datos * @author Cesar Giraldo <*****@*****.**> 23/12/2015 * @param LifecycleEventArgs $args */ public function postPersist(LifecycleEventArgs $args) { $entity = $args->getEntity(); $className = get_class($entity); $entityManager = $args->getEntityManager(); $reflectedClass = new \ReflectionClass($className); if ($reflectedClass->hasProperty('consecutive')) { $consecutive = null; $enabledEntity = false; if ($entity instanceof Entity\Item) { $enabledEntity = true; //buscamos la cantidad de items que tiene creado un proyecto para asignar el consecutivo $project = $entity->getProject(); $consecutive = $project->getLastItemConsecutive() + 1; $project->setLastItemConsecutive($consecutive); $entityManager->persist($project); } elseif ($entity instanceof Entity\Sprint) { $enabledEntity = true; //buscamos la cantidad de items que tiene creado un proyecto para asignar el consecutivo $project = $entity->getProject(); $consecutive = $project->getLastSprintConsecutive() + 1; $project->setLastSprintConsecutive($consecutive); $entityManager->persist($project); } if ($enabledEntity) { if ($consecutive != null) { $entity->setConsecutive($consecutive); } else { $entity->setConsecutive(1); } $entityManager->flush(); } } }
public function setBriefProperty($object, $name, $value, $expectedClass = null) { $reflection = new \ReflectionClass($object); if (!$reflection->hasProperty($name)) { return false; } $property = $reflection->getProperty($name); $property->setAccessible(true); if ($value instanceof Resource) { $value = $value->getUri(); $annotation = $this->annotationReader->getPropertyAnnotation($property, 'Soil\\CommentsDigestBundle\\Annotation\\Entity'); if ($annotation) { $expectedClass = $annotation->value ?: true; var_dump($expectedClass); try { $entity = $this->resolver->getEntityForURI($value, $expectedClass); } catch (\Exception $e) { $entity = null; echo "Problem with discovering" . PHP_EOL; echo $e->getMessage() . PHP_EOL; var_dump($value, $expectedClass); echo PHP_EOL; //FIXME: Add logging } if ($entity) { $value = $entity; } } } elseif ($value instanceof Literal) { $value = $value->getValue(); } $property->setValue($object, $value); }
/** * @param $tableField TableField * @param $value object * @param $propertyName string * @param $destination object * @return mixed|EntityProxy */ private function setPropertyValue($tableField, $value, $propertyName, $destination) { if (!is_null($value)) { if ($tableField->isNumericType()) { settype($value, "float"); } elseif ($tableField->isBoolType()) { settype($value, "boolean"); } elseif ($tableField->isStringType()) { settype($value, "string"); } } if ($fkConstraint = $tableField->getForeignKeyConstraint()) { if ($fkConstraint->isOneToMany()) { $referencedTableData = $fkConstraint->getForeignKeyField()->getTable(); $entity = $referencedTableData->getEntityInstance(); $value = new CollectionProxy($destination, $this->daoFactory->getDaoFromEntity($entity), $tableField); } else { $referencedTableData = $fkConstraint->getForeignKeyField()->getTable(); $entity = $referencedTableData->getEntityInstance(); $value = new EntityProxy($destination, $entity, $this->daoFactory->getDaoFromEntity($entity), $tableField); } } if ($this->reflectionEntityClass->hasProperty($propertyName)) { $property = $this->reflectionEntityClass->getProperty($propertyName); if (!$property->isPublic()) { $property->setAccessible(true); $property->setValue($destination, $value); $property->setAccessible(false); } else { $property->setValue($destination, $value); } } else { $destination->{$propertyName} = $value; } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { foreach ($container->findTaggedServiceIds('mautic.model') as $id => $tags) { $definition = $container->findDefinition($id); $definition->addMethodCall('setEntityManager', [new Reference('doctrine.orm.entity_manager')]); $definition->addMethodCall('setSecurity', [new Reference('mautic.security')]); $definition->addMethodCall('setDispatcher', [new Reference('event_dispatcher')]); $definition->addMethodCall('setTranslator', [new Reference('translator')]); $definition->addMethodCall('setUserHelper', [new Reference('mautic.helper.user')]); $modelClass = $definition->getClass(); $reflected = new \ReflectionClass($modelClass); if ($reflected->hasMethod('setRouter')) { $definition->addMethodCall('setRouter', [new Reference('router')]); } if ($reflected->hasMethod('setLogger')) { $definition->addMethodCall('setLogger', [new Reference('monolog.logger.mautic')]); } if ($reflected->hasMethod('setSession')) { $definition->addMethodCall('setSession', [new Reference('session')]); } // Temporary, for development purposes if ($reflected->hasProperty('factory')) { $definition->addMethodCall('setFactory', [new Reference('mautic.factory')]); } } }
public function enterNode(\PHPParser_Node $node) { if ($node instanceof \PHPParser_Node_Stmt_Namespace) { $this->namespace = implode('\\', $node->name->parts); return; } if (!$node instanceof \PHPParser_Node_Stmt_Class) { return; } $name = '' === $this->namespace ? $node->name : $this->namespace . '\\' . $node->name; if (!class_exists($name)) { return; } if (!is_a($name, 'Symfony\\Component\\Validator\\Constraint', true)) { return; } $constraint = $name::create($this->app); $ref = new \ReflectionClass($name); foreach ($this->messageProperties as $prop) { if ($ref->hasProperty($prop)) { $message = new Message($constraint->{$prop}, 'validators'); $this->catalogue->add($message); } } }
private function _init(\ReflectionClass $rc, $property_name, SymforceAbstractAnnotation $annotation) { $this->class_reflection = $rc; $this->property_name = $property_name; $this->annotation_name = $annotation::SYMFORCE_ANNOTATION_NAME; $value_property_name = $annotation::SYMFORCE_ANNOTATION_VALUE_AS_PROPERTY; if ($value_property_name) { $_rc = new \ReflectionClass($annotation); if (!$_rc->hasProperty($value_property_name)) { throw new \Exception(); } $value_property_as_key = $annotation::SYMFORCE_ANNOTATION_VALUE_AS_KEY; $value_property_not_null = $annotation::SYMFORCE_ANNOTATION_VALUE_NOT_NULL; $value_property_value = $_rc->getProperty($value_property_name)->getValue($annotation); if (!$value_property_value) { if ($value_property_not_null) { throw new \Exception(sprintf("%s annotation.%s can not be null", $this->getAnnotationResourceDescription(), $value_property_name)); } $this->value = $annotation; } else { if ($value_property_as_key) { $this->values[$value_property_value] = $annotation; } else { $this->value = $annotation; } } } else { $this->value = $annotation; } }
public static function toObject() { $args = func_get_args(); if (count($args) >= 2) { $className = '\\' . str_replace('.', '\\', $args[0]); $refClass = new \ReflectionClass($className); $toObjInstance = $refClass->newInstance(); unset($args[0]); foreach ($args as $arg) { if (is_object($arg)) { $arg = Object::getProperties($arg); } if (is_array($arg)) { foreach ($arg as $propertyName => $propertyValue) { if ($refClass->hasProperty($propertyName)) { $property = $refClass->getProperty($propertyName); $property->setAccessible(true); $property->setValue($toObjInstance, $propertyValue); } } } } return $toObjInstance; } }
/** * Initialize preferences * * @access public * @param array * @return void */ public function initialize(array $config = array(), $reset = TRUE) { $reflection = new ReflectionClass($this); if ($reset === TRUE) { $defaults = $reflection->getDefaultProperties(); foreach (array_keys($defaults) as $key) { if ($key[0] === '_') { continue; } if (isset($config[$key])) { if ($reflection->hasMethod('set_' . $key)) { $this->{'set_' . $key}($config[$key]); } else { $this->{$key} = $config[$key]; } } else { $this->{$key} = $defaults[$key]; } } } else { foreach ($config as $key => &$value) { if ($key[0] !== '_' && $reflection->hasProperty($key)) { if ($reflection->hasMethod('set_' . $key)) { $this->{'set_' . $key}($value); } else { $this->{$key} = $value; } } } } // if a file_name was provided in the config, use it instead of the user input // supplied file name for all uploads until initialized again $this->_file_name_override = $this->file_name; return $this; }
public static function castArrayObject(\ArrayObject $c, array $a, Stub $stub, $isNested) { $class = $stub->class; $flags = $c->getFlags(); $b = array("~flag::STD_PROP_LIST" => (bool) ($flags & \ArrayObject::STD_PROP_LIST), "~flag::ARRAY_AS_PROPS" => (bool) ($flags & \ArrayObject::ARRAY_AS_PROPS), "~iteratorClass" => $c->getIteratorClass(), "~storage" => $c->getArrayCopy()); if ($class === 'ArrayObject') { $a = $b; } else { if (!($flags & \ArrayObject::STD_PROP_LIST)) { $c->setFlags(\ArrayObject::STD_PROP_LIST); if ($a = (array) $c) { $class = new \ReflectionClass($class); foreach ($a as $k => $p) { if (!isset($k[0]) || "" !== $k[0] && !$class->hasProperty($k)) { unset($a[$k]); $a["+" . $k] = $p; } } } $c->setFlags($flags); } $a += $b; } return $a; }
/** * Creates or gets an instance for class with class * * *Additional args* can be passed to this method. In this case they will be used to instantiate * the new class. If new class is instance of {@link AbsPluginSingleton} or {@link AbsCoreSingleton} * then additional args will be discarded. If class to be instantiated has $plugin property then the plugin * instance is added to the head of additional args. In that case the class constructor should have `Plugin $plugin` * argument first. * * **IMPORTANT** If class is instance of {@link AbsPluginSingleton} or {@link AbsCoreSingleton} then * {@link AbsPluginSingleton::getInstance()} or {@link AbsCoreSingleton::getInstance()} * is used. In that case any additional args will be discarded. If this is not the case then a new * instance of class is returned. * * @param string $className baseNamespace must be omitted. eg. `$className = 'MyBaseNamespaceChildren\MyClass' * * @return object An instance of [baseNamespace]\$className * @throws Exception If class not found or isn't instantiable or is plugin class has same name as one in core and * doesn't extend this core class. * @author Panagiotis Vagenas <*****@*****.**> * @since 0.0.2 */ public function createOrGet($className) { if ($this->existsInPlugin($className)) { if ($this->coreClassExists($className) && !$this->isCoreExtension($className)) { throw new Exception('Classes that have core name should ALWAYS extend core classes. Class name: ' . $className); } $class = $this->getPluginClassName($className); } elseif ($this->coreClassExists($className)) { $class = $this->getCoreClassName($className); } else { throw new Exception('Class ' . $className . ' doesn\'t seem to exists!'); } $args = func_get_args(); array_shift($args); $reflection = new \ReflectionClass($class); if (!$reflection || !($reflection->isSubclassOf($this->getCoreClassNameFromBase('Abs\\AbsPluginSingleton')) || $reflection->isSubclassOf($this->getCoreClassNameFromBase('Abs\\AbsCoreSingleton'))) && !$reflection->isInstantiable()) { throw new Exception('Trying to instantiate non-instantiable class ' . $class); } if ($reflection->isSubclassOf($this->getCoreClassNameFromBase('Abs\\AbsPluginSingleton'))) { /* @var AbsPluginSingleton $class */ $instance = $class::getInstance($this->plugin); } elseif ($reflection->isSubclassOf($this->getCoreClassNameFromBase('Abs\\AbsCoreSingleton'))) { /* @var AbsCoreSingleton $class */ $instance = $class::getInstance(); } else { if ($reflection->hasProperty('plugin') && (empty($args) || isset($args[0]) && !$args[0] instanceof Plugin)) { array_unshift($args, $this->plugin); } $instance = $reflection->newInstanceArgs($args); } return $instance; }
public function getPropertyTwigValue($property, $object) { if (isset($this->_property_twig_value[$property])) { $access = $this->_property_twig_value[$property]; } else { $access = null; $get = 'get' . $this->camelize($property); if ($this->reflection->hasMethod($get)) { $method = $this->reflection->getMethod($get); if ($method->isPublic() && !$method->isStatic() && !count($method->getParameters())) { $access = '.' . $get . '()'; } } else { if ($this->reflection->hasProperty($property)) { $prop = $this->reflection->getProperty($property); if ($prop->isPublic()) { $access = '.' . $property; } else { $access = false; } } else { throw new \Exception(sprintf("admin(%s) do not has property(%s->%s), and do not has methed(%s)", $this->name, $this->class_name, $property, $get)); } } $this->_property_twig_value[$property] = $access; } if (false === $access) { return sprintf('attribute(%s, "%s")', $object, $property); } return sprintf('%s%s', $object, $access); }
public function __construct($id = null, $name = null, $args = null) { settype($id, 'int'); settype($name, 'string'); settype($args, 'array'); if ($id > 0) { $this->load($id); } elseif (strlen($name) > 0) { if (!class_exists($name)) { throw new Exception("Class {$name} not exists"); } // if ( sizeof($args) > 0 ) // { $reflection = new ReflectionClass($name); if (!$reflection->hasProperty('jObjects')) { throw new Exception("Class not supported by jObjects"); } $this->_instance = call_user_func_array(array(&$reflection, 'newInstance'), $args); // } // else // $this->_instance = new $name(); $this->save(); } else { throw new Exception('Bad parameters'); } }
/** * Map collection by key. For objects, return the property, use * get method or is method, if avaliable. * * @param array $input Array of arrays or objects. * @param string $key Key to map by. * @throws \InvalidArgumentException If array item is not an array or object. * @throws \LogicException If array item could not be mapped by given key. * @return array Mapped array. */ public function mapBy(array $input, $key) { return array_map(function ($item) use($key) { if (is_array($item)) { if (!array_key_exists($key, $item)) { throw new \LogicException("Could not map item by key \"{$key}\". Array key does not exist."); } return $item[$key]; } if (!is_object($item)) { throw new \InvalidArgumentException("Item must be an array or object."); } $ref = new \ReflectionClass($item); if ($ref->hasProperty($key) && $ref->getProperty($key)->isPublic()) { return $item->{$key}; } if ($ref->hasMethod($key) && !$ref->getMethod($key)->isPrivate()) { return $item->{$key}(); } $get = 'get' . ucfirst($key); if ($ref->hasMethod($get) && !$ref->getMethod($get)->isPrivate()) { return $item->{$get}(); } $is = 'is' . ucfirst($key); if ($ref->hasMethod($is) && !$ref->getMethod($is)->isPrivate()) { return $item->{$is}(); } throw new \LogicException("Could not map item by key \"{$key}\". Cannot access the property directly or through getter/is method."); }, $input); }
public function testClassBrowserResult() { $class = new \ReflectionClass('WhichBrowser\\Model\\Browser'); $this->assertTrue($class->hasMethod('getName'), 'method getName() does not exist anymore'); $this->assertTrue($class->hasMethod('getVersion'), 'method getVersion() does not exist anymore'); $this->assertTrue($class->hasProperty('using'), 'property using does not exist anymore'); }
/** * @param array $mapping */ private function initReflField(array $mapping) { if ($this->reflClass->hasProperty($mapping['fieldName'])) { $reflProp = $this->reflClass->getProperty($mapping['fieldName']); $reflProp->setAccessible(true); $this->reflFields[$mapping['fieldName']] = $reflProp; } }
/** * @param string $name * @param string $type * @param array $options * * @return $this */ public function add($name, $type = 'string', array $options = array()) { $getMethod = 'get' . ucfirst($name); $isMethod = 'is' . ucfirst($name); $isAccessible = false; if ($this->reflectionClass->hasProperty($name) && $this->reflectionClass->getProperty($name)->isPublic() || $this->reflectionClass->hasMethod($getMethod) && $this->reflectionClass->getMethod($getMethod)->isPublic() || $this->reflectionClass->hasMethod($isMethod) && $this->reflectionClass->getMethod($isMethod)->isPublic()) { $isAccessible = true; } if (!$isAccessible) { throw new \InvalidArgumentException(sprintf('There is no public property, get or is method for: %s!', $name)); } if (!$type instanceof TypeInterface) { $type = $this->getType($type); } $this->fields[] = new Field($name, $type->getName(), $type->getTemplate(), $options); return $this; }
/** * Magic function which handles the get properties accessibility. * @param string $propertyName The property name. */ public function __get($propertyName) { $class = new \ReflectionClass($this); if ($class->hasProperty($propertyName)) { $property = $class->getProperty($propertyName); $property->setAccessible(true); return $property->getValue($this); } else { if ($class->hasProperty('_' . $propertyName)) { $property = $class->getProperty('_' . $propertyName); $property->setAccessible(true); return $property->getValue($this); } } // EXCEPTION!! return null; }
function it_throws_exception_when_setProducts_method_does_not_exist(ManagerRegistry $registry, EntityManager $em, LifecycleEventArgs $args, ClassMetadata $metadata, \ReflectionClass $reflClass, LifecycleEventArgs $args, InvalidProductsAware $entity) { $args->getEntity()->willReturn($entity); $args->getEntityManager()->willReturn($em); $em->getClassMetadata(Argument::type('string'))->willReturn($metadata); $metadata->reflClass = $reflClass; $reflClass->hasProperty('products')->willReturn(false); $this->shouldThrow('\\LogicException')->duringPostLoad($args); }
/** * @param $target * @param $source * @param $propertyName * @throws InvalidArgumentException * @throws NotExistingPropertyException */ public function cloneProperty($target, $source, $propertyName) { $this->validaObjects($target, $source); $reflection = new \ReflectionClass($target); if (!$reflection->hasProperty($propertyName)) { throw new NotExistingPropertyException(); } $this->propertyAccessor->setValue($target, $propertyName, $this->propertyAccessor->getValue($source, $propertyName)); }