PHP Assert::notEmpty方法代码示例

 /**
  * {@inheritdoc}
  */
 public static function create($body, DescriptionFactory $descriptionFactory = null, FqsenResolver $resolver = null, Context $context = null)
 {
     Assert::string($body);
     Assert::notEmpty($body);
     $parts = preg_split('/\\s+/Su', $body, 2);
     return new static($resolver->resolve($parts[0], $context), $descriptionFactory->create(isset($parts[1]) ? $parts[1] : '', $context));
 }

 /**
  * @return Element
  */
 private function getLastOptionValueElement()
 {
     $optionValues = $this->getElement('values');
     $items = $optionValues->findAll('css', 'div[data-form-collection="item"]');
     Assert::notEmpty($items);
     return end($items);
 }

 /**
  * @return Element
  */
 private function getLastProvinceElement()
 {
     $provinces = $this->getElement('provinces');
     $items = $provinces->findAll('css', 'div[data-form-collection="item"]');
     Assert::notEmpty($items);
     return end($items);
 }

 /**
  * @param RepositoryInterface $repository
  *
  * @return \Closure
  */
 public static function randomOne(RepositoryInterface $repository)
 {
     return function (Options $options) use($repository) {
         $objects = $repository->findAll();
         Assert::notEmpty($objects);
         return $objects[array_rand($objects)];
     };
 }

 /**
  * @Transform /^"([^"]+)" variant of product "([^"]+)"$/
  */
 public function getProductVariantByNameAndProduct($variantName, $productName)
 {
     $products = $this->productRepository->findByName($productName, 'en_US');
     Assert::eq(1, count($products), sprintf('%d products has been found with name "%s".', count($products), $productName));
     $productVariants = $this->productVariantRepository->findByNameAndProduct($variantName, 'en_US', $products[0]);
     Assert::notEmpty($productVariants, sprintf('Product variant with name "%s" of product "%s" does not exist', $variantName, $productName));
     return $productVariants[0];
 }

 /**
  * @Transform /^this order made by "([^"]+)"$/
  */
 public function getOrderByCustomer($email)
 {
     $customer = $this->customerRepository->findOneBy(['email' => $email]);
     Assert::notNull($customer, sprintf('Cannot find customer with email %s.', $email));
     $orders = $this->orderRepository->findByCustomer($customer);
     Assert::notEmpty($orders);
     return end($orders);
 }

 /**
  * Creates a new command name.
  *
  * @param string   $string  The command name.
  * @param string[] $aliases The alias names.
  */
 public function __construct($string, array $aliases = array())
 {
     Assert::string($string, 'The command name must be a string. Got: %s');
     Assert::notEmpty($string, 'The command name must not be empty.');
     Assert::regex($string, '~^[a-zA-Z0-9\\-]+$~', 'The command name must contain letters, digits and hyphens only. Got: "%s"');
     Assert::allString($aliases, 'The command aliases must be strings. Got: %s');
     Assert::allNotEmpty($aliases, 'The command aliases must not be empty.');
     Assert::allRegex($aliases, '~^[a-zA-Z0-9\\-]+$~', 'The command aliases must contain letters, digits and hyphens only. Got: "%s"');
     $this->string = $string;
     $this->aliases = $aliases;
 }

 /**
  * @param RepositoryInterface $repository
  *
  * @return \Closure
  */
 public static function randomOne(RepositoryInterface $repository)
 {
     return function (Options $options) use($repository) {
         $objects = $repository->findAll();
         if ($objects instanceof Collection) {
             $objects = $objects->toArray();
         }
         Assert::notEmpty($objects);
         return $objects[array_rand($objects)];
     };
 }

 /**
  * {@inheritDoc}
  */
 public function getSubscribedEvents()
 {
     return ['phpab.participation.variant_run' => function (array $options) {
         Assert::notEmpty($options, 'Array passed to closure cannot be empty.');
         Assert::keyExists($options, 1, 'Second parameter passed to closure must be instance of Bag.');
         Assert::isInstanceOf($options[1], 'PhpAb\\Test\\Bag', 'Second parameter passed to closure must be instance of Bag.');
         Assert::keyExists($options, 2, 'Third parameter passed to closure must be instance of VariantInterface.');
         Assert::isInstanceOf($options[2], 'PhpAb\\Variant\\VariantInterface', 'Third parameter passed to closure must be instance of VariantInterface.');
         /** @var TestInterface $test */
         $test = $options[1]->getTest();
         /** @var VariantInterface $chosenVariant */
         $chosenVariant = $options[2];
         // Call the add method
         $this->addParticipation($test->getIdentifier(), $chosenVariant->getIdentifier());
     }];
 }

 /**
  * {@inheritDoc}
  */
 public function getSubscribedEvents()
 {
     return ['phpab.participation.variant_run' => function ($options) {
         Assert::notEmpty($options, 'Array passed to closure cannot be empty.');
         Assert::keyExists($options, 1, 'Second parameter passed to closure must be instance of Bag.');
         Assert::isInstanceOf($options[1], 'PhpAb\\Test\\Bag', 'Second parameter passed to closure must be instance of Bag.');
         Assert::keyExists($options, 2, 'Third parameter passed to closure must be instance of VariantInterface.');
         Assert::isInstanceOf($options[2], 'PhpAb\\Variant\\VariantInterface', 'Third parameter passed to closure must be instance of VariantInterface.');
         /** @var TestInterface $test */
         $test = $options[1]->getTest();
         Assert::keyExists($test->getOptions(), static::EXPERIMENT_ID, 'A Google Analytics Experiment Id must be set as options.');
         $experimentId = $test->getOptions()[static::EXPERIMENT_ID];
         /** @var VariantInterface $chosenVariant */
         $chosenVariant = $options[2];
         $variants = $test->getVariants();
         // Get the index number of the element
         $chosenIndex = array_search($chosenVariant->getIdentifier(), array_keys($variants));
         // Call the add method
         $this->addParticipation($experimentId, $chosenIndex);
     }];
 }

 /**
  * @param string $body
  */
 public function setBody($body)
 {
     \Webmozart\Assert\Assert::string($body);
     \Webmozart\Assert\Assert::notEmpty($body);
     $this->body = $body;
 }

 /**
  * @param NodeElement $table
  * @param string $columnName
  *
  * @return int
  *
  * @throws \Exception If column was not found
  */
 private function getColumnIndex(NodeElement $table, $columnName)
 {
     $rows = $table->findAll('css', 'tr');
     Assert::notEmpty($rows, 'There are no rows!');
     /** @var NodeElement $firstRow */
     $firstRow = $rows[0];
     $columns = $firstRow->findAll('css', 'th,td');
     foreach ($columns as $index => $column) {
         /** @var NodeElement $column */
         if (0 === stripos($column->getText(), $columnName)) {
             return $index;
         }
     }
     throw new \InvalidArgumentException(sprintf('Column with name "%s" not found!', $columnName));
 }

 /**
  * @param string $collection
  *
  * @return NodeElement
  */
 private function getLastCollectionItem($collection)
 {
     $items = $this->getCollectionItems($collection);
     Assert::notEmpty($items);
     return end($items);
 }

 /**
  * @param PromotionEligibilityCheckerInterface[] $promotionEligibilityCheckers
  */
 public function __construct(array $promotionEligibilityCheckers)
 {
     Assert::notEmpty($promotionEligibilityCheckers);
     Assert::allIsInstanceOf($promotionEligibilityCheckers, PromotionEligibilityCheckerInterface::class);
     $this->promotionEligibilityCheckers = $promotionEligibilityCheckers;
 }

 /**
  * {@inheritdoc}
  */
 public function remove($query, $language = 'glob')
 {
     if (null === $this->json) {
         $this->load();
     }
     $this->failUnlessGlob($language);
     $query = $this->sanitizePath($query);
     Assert::notEmpty(trim($query, '/'), 'The root directory cannot be removed.');
     $removed = $this->removeReferences($query);
     $this->flush();
     return $removed;
 }