PHP Assert::isEqual方法代码示例

 public function importValue($value)
 {
     if ($value) {
         Assert::isEqual(get_class($value), $this->className);
     } else {
         return parent::importValue(null);
     }
     return $this->import([$this->getName() => $value->getId()]);
 }

 /**
  * @return Form
  **/
 public function fillOwn($object, &$result)
 {
     Assert::isInstance($result, Form::class);
     foreach ($this->getFormMapping() as $primitive) {
         if ($primitive instanceof PrimitiveForm && $result->exists($primitive->getName()) && $primitive->isComposite()) {
             Assert::isEqual($primitive->getProto(), $result->get($primitive->getName())->getProto());
             continue;
         }
         $result->add($primitive);
     }
     $result = parent::fillOwn($object, $result);
     $result->setProto($this->proto);
     return $result;
 }

 public static function copyProperties($source, $destination)
 {
     Assert::isEqual(get_class($source), get_class($destination));
     $class = new \ReflectionClass($source);
     foreach ($class->getProperties() as $property) {
         $name = ucfirst($property->getName());
         $getter = 'get' . $name;
         $setter = 'set' . $name;
         if ($class->hasMethod($getter) && $class->hasMethod($setter)) {
             $sourceValue = $source->{$getter}();
             if ($sourceValue === null) {
                 $setMethood = $class->getMethod($setter);
                 $parameterList = $setMethood->getParameters();
                 $firstParameter = $parameterList[0];
                 if ($firstParameter->allowsNull()) {
                     $destination->{$setter}($sourceValue);
                 }
             } else {
                 $destination->{$setter}($sourceValue);
             }
         }
     }
 }

 public static function getCovariance(array $list1, array $list2)
 {
     $list1Size = count($list1);
     $list2Size = count($list2);
     Assert::isEqual($list1Size, $list2Size, 'Array sizes should be equals!');
     $list1AverageValue = self::getAverage($list1);
     $list2AverageValue = self::getAverage($list2);
     $tempSum = 0;
     for ($i = 0; $i < $list1Size; $i++) {
         $elt1Dev = self::getMeanDeviation($list1[$i], $list1AverageValue);
         $elt2Dev = self::getMeanDeviation($list2[$i], $list2AverageValue);
         $tempSum += $elt1Dev * $elt2Dev;
     }
     return $tempSum / ($list1Size - 1);
 }

 public final function validateList($objectsList, $formsList, $previousObjectsList = null)
 {
     Assert::isEqual(count($objectsList), count($formsList));
     reset($formsList);
     if ($previousObjectsList) {
         Assert::isEqual(count($objectsList), count($previousObjectsList));
         reset($previousObjectsList);
     }
     $result = true;
     $previousObject = null;
     foreach ($objectsList as $object) {
         $form = current($formsList);
         next($formsList);
         if ($previousObjectsList) {
             $previousObject = current($previousObjectsList);
             next($previousObjectsList);
         }
         if (!$this->validate($object, $form, $previousObject)) {
             $result = false;
         }
     }
     return $result;
 }

 protected function call($method, DTOMessage $request, $resultClass)
 {
     $requestDto = $request->makeDto();
     Assert::isInstance($requestDto, DTOClass::class);
     if (defined('__LOCAL_DEBUG__') && !defined('SIMPLE_TEST')) {
         // self-validation
         $form = ObjectToFormConverter::create($request->entityProto())->make($request);
         Assert::isTrue(!$form->getErrors() && $request->entityProto()->validate($request, $form), Assert::dumpArgument($request));
     }
     try {
         try {
             $resultDto = $this->getSoapClient()->{$method}($requestDto);
         } catch (BaseException $e) {
             if (get_class($e) == BaseException::class) {
                 throw new SoapFault('Server', get_class($e) . ': ' . $e->getMessage());
             } else {
                 $this->logCall();
                 throw $e;
             }
         }
     } catch (SoapFault $e) {
         $this->logCall();
         throw self::convertSoapFault($e);
     }
     $this->logCall();
     if (!$resultClass) {
         Assert::isNull($resultDto);
         $result = null;
     } else {
         Assert::isInstance($resultDto, DTOClass::class);
         Assert::isEqual($resultDto->entityProto()->className(), $resultClass);
         $form = DTOToFormImporter::create($resultDto->entityProto())->make($resultDto);
         Assert::isTrue(!$form->getErrors(), Assert::dumpArgument($resultDto));
         $result = $resultDto->makeObject($form);
         Assert::isInstance($result, DTOMessage::class);
         Assert::isEqual(get_class($result), $resultClass);
         Assert::isTrue($result->entityProto()->validate($result, $form), Assert::dumpArgument($result));
     }
     return $result;
 }

 public static function makeUniqueLatinName($originalName)
 {
     $extension = substr($originalName, strrpos($originalName, '.'));
     Assert::isEqual(preg_match('/\\.[^0-9a-zA-Z]/', $extension), 0, 'I don\'t know how to work with this extension: ' . $extension);
     return time() . '_' . uniqid() . $extension;
 }

 public static function setChars($chars)
 {
     self::check($chars);
     Assert::isEqual(mb_strlen($chars), 62, 'Wrong length');
     self::$chars = $chars;
 }

 private function __construct($name)
 {
     $units = self::getUnits();
     if (!isset($units[$name])) {
         throw new WrongArgumentException("know nothing about unit '{$name}'");
     }
     if (!$units[$name]) {
         throw new UnimplementedFeatureException('need for complex logic, see manual');
     }
     $this->name = $name;
     $this->months = $units[$name][0];
     $this->days = $units[$name][1];
     $this->seconds = $units[$name][2];
     $notNulls = 0;
     if ($this->months > 0) {
         ++$notNulls;
     }
     if ($this->days > 0) {
         ++$notNulls;
     }
     if ($this->seconds > 0) {
         ++$notNulls;
     }
     Assert::isEqual($notNulls, 1, "broken unit '{$name}'");
 }

 /**
  * @return MetaConfiguration
  **/
 public function checkIntegrity()
 {
     $out = $this->getOutput()->newLine()->infoLine('Checking sanity of generated files: ')->newLine();
     $out->info("\t");
     $formErrors = [];
     foreach ($this->classes as $name => $class) {
         if (!($class->getPattern() instanceof SpookedClassPattern || $class->getPattern() instanceof SpookedEnumerationPattern || $class->getPattern() instanceof SpookedEnumPattern || $class->getPattern() instanceof SpookedRegistryPattern || $class->getPattern() instanceof InternalClassPattern) && class_exists(MetaClassNameBuilder::getClassOfMetaClass($class, true))) {
             $out->info($name, true);
             $className = MetaClassNameBuilder::getClassOfMetaClass($class);
             $info = new \ReflectionClass($className);
             $this->checkClassSanity($class, $info);
             if ($info->implementsInterface(Prototyped::class)) {
                 $this->checkClassSanity($class, new \ReflectionClass($class->getProtoClass()));
             }
             if ($info->implementsInterface(DAOConnected::class)) {
                 $this->checkClassSanity($class, new \ReflectionClass($class->getDaoClass()));
             }
             foreach ($class->getInterfaces() as $interface) {
                 Assert::isTrue($info->implementsInterface($interface), 'class ' . $class->getName() . ' expected to implement interface ' . $interface);
             }
             // special handling for Enumeration instances
             if ($class->getPattern() instanceof EnumerationClassPattern || $class->getPattern() instanceof EnumClassPattern || $class->getPattern() instanceof RegistryClassPattern) {
                 $object = new $className(call_user_func([$className, 'getAnyId']));
                 Assert::isTrue(unserialize(serialize($object)) == $object);
                 $out->info(', ');
                 if ($this->checkEnumerationRefIntegrity) {
                     if ($object instanceof Enumeration || $object instanceof Enum || $object instanceof Registry) {
                         $this->checkEnumerationReferentialIntegrity($object, $class->getTableName());
                     }
                 }
                 continue;
             }
             if ($class->getPattern() instanceof AbstractClassPattern) {
                 $out->info(', ');
                 continue;
             }
             /** @var Prototyped $object */
             $object = new $className();
             $proto = $object->proto();
             $form = $proto->makeForm();
             foreach ($class->getProperties() as $name => $property) {
                 Assert::isTrue($property->toLightProperty($class) == $proto->getPropertyByName($name), 'defined property does not match autogenerated one - ' . $class->getName() . '::' . $property->getName());
             }
             if (!$object instanceof DAOConnected) {
                 $out->info(', ');
                 continue;
             }
             $dao = $object->dao();
             Assert::isEqual($dao->getIdName(), $class->getIdentifier()->getColumnName(), 'identifier name mismatch in ' . $class->getName() . ' class');
             try {
                 DBPool::getByDao($dao);
             } catch (MissingElementException $e) {
                 // skipping
                 $out->info(', ');
                 continue;
             }
             $query = Criteria::create($dao)->setLimit(1)->add(Expression::notNull($class->getIdentifier()->getName()))->addOrder($class->getIdentifier()->getName())->toSelectQuery();
             $out->warning(' (' . $query->getFieldsCount() . '/' . $query->getTablesCount() . '/');
             $clone = clone $object;
             if (serialize($clone) == serialize($object)) {
                 $out->info('C', true);
             } else {
                 $out->error('C', true);
             }
             $out->warning('/');
             try {
                 $object = $dao->getByQuery($query);
                 $form = $object->proto()->makeForm();
                 FormUtils::object2form($object, $form);
                 if ($errors = $form->getErrors()) {
                     $formErrors[$class->getName()] = $errors;
                     $out->error('F', true);
                 } else {
                     $out->info('F', true);
                 }
             } catch (ObjectNotFoundException $e) {
                 $out->warning('F');
             }
             $out->warning('/');
             if (Criteria::create($dao)->setFetchStrategy(FetchStrategy::cascade())->toSelectQuery() == $dao->makeSelectHead()) {
                 $out->info('H', true);
             } else {
                 $out->error('H', true);
             }
             $out->warning('/');
             // cloning once again
             $clone = clone $object;
             FormUtils::object2form($object, $form);
             FormUtils::form2object($form, $object);
             if ($object != $clone) {
                 $out->error('T', true);
             } else {
                 $out->info('T', true);
             }
             $out->warning(')')->info(', ');
         }
     }
//.........这里部分代码省略.........

 public static function hex2Binary($hex)
 {
     $length = strlen($hex);
     Assert::isEqual($length % 2, 0);
     $out = null;
     for ($i = 0; $i < $length; $i += 2) {
         $out .= pack('C', hexdec(substr($hex, $i, 2)));
     }
     return $out;
 }

 public function endPrefetch(array $objectList)
 {
     if (!$this->depth) {
         throw new WrongStateException('prefetch mode is already off');
     }
     foreach ($this->storage[$this->depth] as $setter => $innerList) {
         Assert::isEqual(count($objectList), count($innerList) + array_sum($this->skipList[$this->depth]));
         $ids = [];
         foreach ($innerList as $inner) {
             if ($inner) {
                 $ids[] = $inner->getId();
             }
         }
         // finding first available inner object
         foreach ($innerList as $inner) {
             if ($inner) {
                 break;
             }
         }
         if (!$inner) {
             continue;
         }
         // put yet unmapped objects into dao's identityMap
         $inner->dao()->getListByIds($ids);
         $skippedMap = $this->skipList[$this->depth];
         $i = $j = 0;
         foreach ($objectList as $object) {
             $objectId = $object->getId();
             if (isset($skippedMap[$objectId])) {
                 if ($skippedMap[$objectId] == 1) {
                     unset($skippedMap[$objectId]);
                 } else {
                     --$skippedMap[$objectId];
                 }
                 ++$j;
                 continue;
             }
             if ($innerList[$i]) {
                 try {
                     // avoid dao "caching" here
                     // because of possible breakage
                     // in overriden properties
                     $object->{$setter}($innerList[$i]->dao()->getById($innerList[$i]->getId()));
                 } catch (ObjectNotFoundException $e) {
                     throw new WrongStateException('possible corruption found: ' . $e->getMessage());
                 }
             }
             ++$i;
         }
         Assert::isEqual($i, count($objectList) - $j);
     }
     unset($this->skipList[$this->depth], $this->storage[$this->depth--]);
     return $objectList;
 }

 private function assertSavePointName($savepointName)
 {
     Assert::isEqual(1, preg_match('~^[A-Za-z][A-Za-z0-9]*$~iu', $savepointName));
 }

 public function store($localFile, $desiredName)
 {
     if (!is_readable($localFile) || !is_file($localFile)) {
         throw new WrongArgumentException('Wrong file: ' . $localFile);
     }
     if (preg_match($this->unAllowedName, $desiredName)) {
         throw new WrongArgumentException('Wrong desired name: ' . $desiredName);
     }
     $origDesiredName = $desiredName;
     $desiredNameFull = $this->getPath($desiredName, true);
     if ($this->exists($desiredName) && $this->resolveNameConflicts) {
         $desiredName = $this->generateName($desiredName);
         $desiredNameFull = $this->getPath($desiredName, true);
     }
     if ($this->exists($desiredName)) {
         throw new Exception('File name conflict:' . $origDesiredName . '"');
     }
     $context = $this->context;
     $upload = function () use($localFile, $desiredNameFull, $desiredName, $context) {
         $src = fopen($localFile, 'rb');
         $dst = fopen($desiredNameFull, 'wb', false, $context);
         Assert::isEqual(stream_copy_to_stream($src, $dst), filesize($localFile), 'Bytes copied mismatch');
         $this->closeHandles($src, $dst);
         if (!$this->exists($desiredName)) {
             throw new Exception('Could not find file after upload"' . $desiredName . '", linkId: ' . $this->linkId);
         }
     };
     $this->tryToDo($upload, 'Couldn`t store file ' . $origDesiredName . ', reason: %s');
     return $desiredName;
 }