* Renamed VerifyObject.php to VerifyBaseObject.php

* Add use function statements
* Updated supported_verifiers.md

Author: TavoNiievez

docs/supported_verifiers.md

@@ -17,81 +17,107 @@ notSameSize
 sameSize
 ```
 
+### Callable
+```
+throws
+doesNotThrow
+```
+
+### Class
+```
+hasAttribute
+hasStaticAttribute
+notHasAttribute
+notHasStaticAttribute
+```
+
 ### Directory
 ```
-directoryDoesNotExist
-directoryExists
-directoryIsNotReadable
-directoryIsNotWritable
-directoryIsReadable
-directoryIsWritable
+doesNotExist
+exists
+isNotReadable
+isNotWritable
+isReadable
+isWritable
 ```
+
 ### File
 ```
-setIsFileExpectation
+doesNotExists
 equals
-notEquals
+equalsCanonicalizing
+equalsIgnoringCase
 exists
-notExists
+isNotReadable
+isNotWritable
+isReadable
+isWritable
+notEquals
+notEqualsCanonicalizing
+notEqualsIgnoringCase
+```
+
+### JsonFile
+```
 equalsJsonFile
-equalsXmlFile
-fileEqualsCanonicalizing
-fileEqualsIgnoringCase
-fileIsNotReadable
-fileIsNotWritable
-fileIsReadable
-fileIsWritable
-fileNotEqualsCanonicalizing
-fileNotEqualsIgnoringCase
-jsonFileNotEqualsJsonFile
-jsonStringNotEqualsJsonFile
+notEqualsJsonFile
+```
+
+### JsonString
+```
+equalsJsonFile
+equalsJsonString
+notEqualsJsonFile
+notEqualsJsonString
 ```
 
 ### Mixed
 ```
-isEmpty
+empty
+equals
 equalsCanonicalizing
 equalsIgnoringCase
 equalsWithDelta
 false
 finite
 greaterThan
-greaterOrEquals
+greaterThanOrEqual
 infinite
-isInstanceOf
-array
-bool
-callable
+instanceOf
+isArray
+isBool
+isCallable
 isClosedResource
-float
-int
+isFloat
+isInt
 isIterable
-notArray
-notBool
-notCallable
+isNotArray
+isNotBool
+isNotCallable
 isNotClosedResource
-notFloat
-notInt
+isNotFloat
+isNotInt
 isNotIterable
-notNumeric
-notObject
-notResource
-notScalar
-notString
-numeric
-object
-resource
-scalar
-string
+isNotNumeric
+isNotObject
+isNotResource
+isNotScalar
+isNotString
+isNumeric
+isObject
+isResource
+isScalar
+isString
 lessThan
-lessOrEquals
+lessThanOrEqual
 nan
 notEmpty
+notEquals
 notEqualsCanonicalizing
 notEqualsIgnoringCase
 notEqualsWithDelta
 notFalse
-isNotInstanceOf
+notInstanceOf
 notNull
 notSame
 notTrue
@@ -103,55 +129,39 @@ true
 
 ### String
 ```
-hasStaticAttribute
-notHasStaticAttribute
-json
-jsonStringNotEqualsJsonString
-notRegExp
-equalsJsonString
-regExp
-stringContainsString
-stringContainsStringIgnoringCase
-stringEqualsFileCanonicalizing
-stringEqualsFileIgnoringCase
-stringNotEqualsFileCanonicalizing
-stringNotEqualsFileIgnoringCase
-notEndsWith
+containsString
+containsStringIgnoringCase
+doesNotMatchRegExp
 endsWith
 equalsFile
+equalsFileCanonicalizing
+equalsFileIgnoringCase
+json
 matchesFormat
 matchesFormatFile
-stringNotContainsString
-stringNotContainsStringIgnoringCase
+matchesRegExp
+notContainsString
+notContainsStringIgnoringCase
+notEndsWith
+notEqualsFile
+notEqualsFileCanonicalizing
+notEqualsFileIgnoringCase
 notMatchesFormat
 notMatchesFormatFile
-notStartsWith
+startsNotWith
 startsWith
-notEqualsFile
 ```
 
-### Union
-##### Object/String
-```
-hasAttribute
-notHasAttribute
-```
-##### File/Directory
-```
-isNotReadable
-isNotWritable
-```
-
-### Throwable
+### String
 ```
-throws
-doesNotThrow
+equalsXmlFile
+notEqualsXmlFile
 ```
 
-### Xml
+### XmlString
 ```
+equalsXmlFile
 equalsXmlString
-xmlFileNotEqualsXmlFile
-xmlStringNotEqualsXmlFile
-xmlStringNotEqualsXmlString
+notEqualsXmlFile
+notEqualsXmlString
 ```

src/Codeception/Exception/InvalidVerifyException.php

@@ -3,6 +3,8 @@
 namespace Codeception\Exception;
 
 use InvalidArgumentException;
+use function gettype;
+use function sprintf;
 
 final class InvalidVerifyException extends InvalidArgumentException
 {

src/Codeception/Verify/Verifiers/VerifyArray.php

@@ -7,6 +7,9 @@
 use Codeception\Verify\Verify;
 use Countable;
 use PHPUnit\Framework\Assert;
+use function basename;
+use function is_array;
+use function is_iterable;
 
 class VerifyArray extends Verify
 {
@@ -26,7 +29,7 @@ public function __construct($actual)
             parent::__construct($actual);
             return;
         }
-        throw new InvalidVerifyException(basename(__CLASS__), $actual);
+        throw new InvalidVerifyException(basename(self::class), $actual);
     }
 
     /**

…eption/Verify/Verifiers/VerifyObject.php …on/Verify/Verifiers/VerifyBaseObject.phpsrc/Codeception/Verify/Verifiers/VerifyObject.php renamed to src/Codeception/Verify/Verifiers/VerifyBaseObject.php src/Codeception/Verify/Verifiers/VerifyObject.php renamed to src/Codeception/Verify/Verifiers/VerifyBaseObject.php

@@ -5,12 +5,12 @@
 use Codeception\Verify\Verify;
 use PHPUnit\Framework\Assert;
 
-class VerifyObject extends Verify
+class VerifyBaseObject extends Verify
 {
     use VerifyDataTrait;
 
     /**
-     * VerifyObject constructor
+     * VerifyBaseObject constructor
      *
      * @param object $object
      */

src/Codeception/Verify/Verifiers/VerifyCallable.php

@@ -30,23 +30,23 @@ public function throws($throws = null, $message = false): self
 
         try {
             call_user_func($this->actual);
-        } catch (Throwable $e) {
+        } catch (Throwable $exception) {
             if (!$throws) {
                 return $this; // it throws
             }
 
-            $actualThrows = get_class($e);
-            $actualMessage = $e->getMessage();
+            $actualThrows = get_class($exception);
+            $actualMessage = $exception->getMessage();
 
-            Assert::assertSame($throws, $actualThrows, "exception '$throws' was expected, but '$actualThrows' was thrown");
+            Assert::assertSame($throws, $actualThrows, sprintf('exception \'%s\' was expected, but \'%s\' was thrown', $throws, $actualThrows));
 
             if ($message) {
-                Assert::assertSame($message, $actualMessage, "exception message '$message' was expected, but '$actualMessage' was received");
+                Assert::assertSame($message, $actualMessage, sprintf('exception message \'%s\' was expected, but \'%s\' was received', $message, $actualMessage));
             }
         }
 
-        if (!isset($e)) {
-            throw new ExpectationFailedException("exception '$throws' was not thrown as expected");
+        if (!isset($exception)) {
+            throw new ExpectationFailedException(sprintf('exception \'%s\' was not thrown as expected', $throws));
         }
 
         return $this;
@@ -66,23 +66,24 @@ public function doesNotThrow($throws = null, $message = false): self
 
         try {
             call_user_func($this->actual);
-        } catch (Throwable $e) {
+        } catch (Throwable $exception) {
             if (!$throws) {
                 throw new ExpectationFailedException('exception was not expected to be thrown');
             }
 
-            $actualThrows = get_class($e);
-            $actualMessage = $e->getMessage();
+            $actualThrows = get_class($exception);
+            $actualMessage = $exception->getMessage();
 
             if ($throws !== $actualThrows) {
                 return $this;
             }
+
             if (!$message) {
-                throw new ExpectationFailedException("exception '$throws' was not expected to be thrown");
+                throw new ExpectationFailedException(sprintf('exception \'%s\' was not expected to be thrown', $throws));
             }
 
             if ($message === $actualMessage) {
-                throw new ExpectationFailedException("exception '$throws' with message '$message' was not expected to be thrown");
+                throw new ExpectationFailedException(sprintf('exception \'%s\' with message \'%s\' was not expected to be thrown', $throws, $message));
             }
         }
 

src/Codeception/Verify/Verifiers/VerifyClass.php

@@ -33,41 +33,41 @@ public function hasAttribute(string $attributeName, string $message = ''): self
     }
 
     /**
-     * Verifies that a class does not have a specified attribute.
+     * Verifies that a class has a specified static attribute.
      *
      * @param string $attributeName
      * @param string $message
      * @return self
      */
-    public function notHasAttribute(string $attributeName, string $message = ''): self
+    public function hasStaticAttribute(string $attributeName, string $message = ''): self
     {
-        Assert::assertClassNotHasAttribute($attributeName, $this->actual, $message);
+        Assert::assertClassHasStaticAttribute($attributeName, $this->actual, $message);
         return $this;
     }
 
     /**
-     * Verifies that a class does not have a specified static attribute.
+     * Verifies that a class does not have a specified attribute.
      *
      * @param string $attributeName
      * @param string $message
      * @return self
      */
-    public function notHasStaticAttribute(string $attributeName, string $message = ''): self
+    public function notHasAttribute(string $attributeName, string $message = ''): self
     {
-        Assert::assertClassNotHasStaticAttribute($attributeName, $this->actual, $message);
+        Assert::assertClassNotHasAttribute($attributeName, $this->actual, $message);
         return $this;
     }
 
     /**
-     * Verifies that a class has a specified static attribute.
+     * Verifies that a class does not have a specified static attribute.
      *
      * @param string $attributeName
      * @param string $message
      * @return self
      */
-    public function hasStaticAttribute(string $attributeName, string $message = ''): self
+    public function notHasStaticAttribute(string $attributeName, string $message = ''): self
     {
-        Assert::assertClassHasStaticAttribute($attributeName, $this->actual, $message);
+        Assert::assertClassNotHasStaticAttribute($attributeName, $this->actual, $message);
         return $this;
     }
 }