[ZF-4352, ZF-6888] Zend_Validate:

 - fixed casting for Alnum, Alpha, Date, Digits, EmailAddress, Float, Hostname, Int, Ip, NotEmpty and Regex validator
 - fixed unittests for both Db validators

git-svn-id: http://framework.zend.com/svn/framework/standard/trunk@15951 44c647ce-9c0f-0410-b52a-842ac1e357ba

library/Zend/Validate/Alnum.php

@@ -32,14 +32,8 @@ require_once 'Zend/Validate/Abstract.php';
  */
 class Zend_Validate_Alnum extends Zend_Validate_Abstract
 {
-    /**
-     * Validation failure message key for when the value contains non-alphabetic or non-digit characters
-     */
-    const NOT_ALNUM = 'notAlnum';
-
-    /**
-     * Validation failure message key for when the value is an empty string
-     */
+    const INVALID      = 'alnumInvalid';
+    const NOT_ALNUM    = 'notAlnum';
     const STRING_EMPTY = 'stringEmpty';
 
     /**
@@ -63,6 +57,7 @@ class Zend_Validate_Alnum extends Zend_Validate_Abstract
      * @var array
      */
     protected $_messageTemplates = array(
+        self::INVALID      => "Invalid type given, value should be float, string, or integer",
         self::NOT_ALNUM    => "'%value%' has not only alphabetic and digit characters",
         self::STRING_EMPTY => "'%value%' is an empty string"
     );
@@ -110,11 +105,14 @@ class Zend_Validate_Alnum extends Zend_Validate_Abstract
      */
     public function isValid($value)
     {
-        $valueString = (string) $value;
+        if (!is_string($value) && !is_int($value) && !is_float($value)) {
+            $this->_error(self::INVALID);
+            return false;
+        }
 
-        $this->_setValue($valueString);
+        $this->_setValue($value);
 
-        if ('' === $valueString) {
+        if ('' === $value) {
             $this->_error(self::STRING_EMPTY);
             return false;
         }
@@ -129,7 +127,7 @@ class Zend_Validate_Alnum extends Zend_Validate_Abstract
 
         self::$_filter->allowWhiteSpace = $this->allowWhiteSpace;
 
-        if ($valueString !== self::$_filter->filter($valueString)) {
+        if ($value !== self::$_filter->filter($value)) {
             $this->_error(self::NOT_ALNUM);
             return false;
         }

library/Zend/Validate/Alpha.php

@@ -1,5 +1,4 @@
 <?php
-
 /**
  * Zend Framework
  *
@@ -20,13 +19,11 @@
  * @version    $Id$
  */
 
-
 /**
  * @see Zend_Validate_Abstract
  */
 require_once 'Zend/Validate/Abstract.php';
 
-
 /**
  * @category   Zend
  * @package    Zend_Validate
@@ -35,14 +32,8 @@ require_once 'Zend/Validate/Abstract.php';
  */
 class Zend_Validate_Alpha extends Zend_Validate_Abstract
 {
-    /**
-     * Validation failure message key for when the value contains non-alphabetic characters
-     */
-    const NOT_ALPHA = 'notAlpha';
-
-    /**
-     * Validation failure message key for when the value is an empty string
-     */
+    const INVALID      = 'alphaInvalid';
+    const NOT_ALPHA    = 'notAlpha';
     const STRING_EMPTY = 'stringEmpty';
 
     /**
@@ -66,6 +57,7 @@ class Zend_Validate_Alpha extends Zend_Validate_Abstract
      * @var array
      */
     protected $_messageTemplates = array(
+        self::INVALID      => "Invalid type given, value should be a string",
         self::NOT_ALPHA    => "'%value%' has not only alphabetic characters",
         self::STRING_EMPTY => "'%value%' is an empty string"
     );
@@ -113,11 +105,14 @@ class Zend_Validate_Alpha extends Zend_Validate_Abstract
      */
     public function isValid($value)
     {
-        $valueString = (string) $value;
+        if (!is_string($value)) {
+            $this->_error(self::INVALID);
+            return false;
+        }
 
-        $this->_setValue($valueString);
+        $this->_setValue($value);
 
-        if ('' === $valueString) {
+        if ('' === $value) {
             $this->_error(self::STRING_EMPTY);
             return false;
         }
@@ -132,7 +127,7 @@ class Zend_Validate_Alpha extends Zend_Validate_Abstract
 
         self::$_filter->allowWhiteSpace = $this->allowWhiteSpace;
 
-        if ($valueString !== self::$_filter->filter($valueString)) {
+        if ($value !== self::$_filter->filter($value)) {
             $this->_error(self::NOT_ALPHA);
             return false;
         }

library/Zend/Validate/Date.php

@@ -32,19 +32,9 @@ require_once 'Zend/Validate/Abstract.php';
  */
 class Zend_Validate_Date extends Zend_Validate_Abstract
 {
-    /**
-     * Validation failure message key for when the value does not follow the YYYY-MM-DD format
-     */
-    const NOT_YYYY_MM_DD = 'dateNotYYYY-MM-DD';
-
-    /**
-     * Validation failure message key for when the value does not appear to be a valid date
-     */
     const INVALID        = 'dateInvalid';
-
-    /**
-     * Validation failure message key for when the value does not fit the given dateformat or locale
-     */
+    const NOT_YYYY_MM_DD = 'dateNotYYYY-MM-DD';
+    const INVALID_DATE    = 'dateInvalidDate';
     const FALSEFORMAT    = 'dateFalseFormat';
 
     /**
@@ -53,8 +43,9 @@ class Zend_Validate_Date extends Zend_Validate_Abstract
      * @var array
      */
     protected $_messageTemplates = array(
+        self::INVALID        => "Invalid type given, value should be string, or integer",
         self::NOT_YYYY_MM_DD => "'%value%' is not of the format YYYY-MM-DD",
-        self::INVALID        => "'%value%' does not appear to be a valid date",
+        self::INVALID_DATE   => "'%value%' does not appear to be a valid date",
         self::FALSEFORMAT    => "'%value%' does not fit given date format"
     );
 
@@ -144,9 +135,12 @@ class Zend_Validate_Date extends Zend_Validate_Abstract
      */
     public function isValid($value)
     {
-        $valueString = (string) $value;
+        if (!is_string($value) && !is_int($value) && !is_float($value)) {
+            $this->_error(self::INVALID);
+            return false;
+        }
 
-        $this->_setValue($valueString);
+        $this->_setValue($value);
 
         if (($this->_format !== null) or ($this->_locale !== null)) {
             require_once 'Zend/Date.php';
@@ -154,20 +148,20 @@ class Zend_Validate_Date extends Zend_Validate_Abstract
                 if ($this->_checkFormat($value) === false) {
                     $this->_error(self::FALSEFORMAT);
                 } else {
-                    $this->_error(self::INVALID);
+                    $this->_error(self::INVALID_DATE);
                 }
                 return false;
             }
         } else {
-            if (!preg_match('/^\d{4}-\d{2}-\d{2}$/', $valueString)) {
+            if (!preg_match('/^\d{4}-\d{2}-\d{2}$/', $value)) {
                 $this->_error(self::NOT_YYYY_MM_DD);
                 return false;
             }
 
-            list($year, $month, $day) = sscanf($valueString, '%d-%d-%d');
+            list($year, $month, $day) = sscanf($value, '%d-%d-%d');
 
             if (!checkdate($month, $day, $year)) {
-                $this->_error(self::INVALID);
+                $this->_error(self::INVALID_DATE);
                 return false;
             }
         }

library/Zend/Validate/Digits.php

@@ -35,14 +35,8 @@ require_once 'Zend/Validate/Abstract.php';
  */
 class Zend_Validate_Digits extends Zend_Validate_Abstract
 {
-    /**
-     * Validation failure message key for when the value contains non-digit characters
-     */
-    const NOT_DIGITS = 'notDigits';
-
-    /**
-     * Validation failure message key for when the value is an empty string
-     */
+    const INVALID      = 'digitsInvalid';
+    const NOT_DIGITS   = 'notDigits';
     const STRING_EMPTY = 'stringEmpty';
 
     /**
@@ -58,6 +52,7 @@ class Zend_Validate_Digits extends Zend_Validate_Abstract
      * @var array
      */
     protected $_messageTemplates = array(
+        self::INVALID      => "Invalid type given, value should be string, integer or float",
         self::NOT_DIGITS   => "'%value%' contains not only digit characters",
         self::STRING_EMPTY => "'%value%' is an empty string"
     );
@@ -72,24 +67,24 @@ class Zend_Validate_Digits extends Zend_Validate_Abstract
      */
     public function isValid($value)
     {
-        $valueString = (string) $value;
+        if (!is_string($value) && !is_int($value) && !is_float($value)) {
+            $this->_error(self::INVALID);
+            return false;
+        }
 
-        $this->_setValue($valueString);
+        $this->_setValue((string) $value);
 
-        if ('' === $valueString) {
+        if ('' === $this->_value) {
             $this->_error(self::STRING_EMPTY);
             return false;
         }
 
         if (null === self::$_filter) {
-            /**
-             * @see Zend_Filter_Digits
-             */
             require_once 'Zend/Filter/Digits.php';
             self::$_filter = new Zend_Filter_Digits();
         }
 
-        if ($valueString !== self::$_filter->filter($valueString)) {
+        if ($this->_value !== self::$_filter->filter($this->_value)) {
             $this->_error(self::NOT_DIGITS);
             return false;
         }

library/Zend/Validate/EmailAddress.php

@@ -38,6 +38,7 @@ require_once 'Zend/Validate/Hostname.php';
 class Zend_Validate_EmailAddress extends Zend_Validate_Abstract
 {
     const INVALID            = 'emailAddressInvalid';
+    const INVALID_FORMAT     = 'emailAddressInvalidFormat';
     const INVALID_HOSTNAME   = 'emailAddressInvalidHostname';
     const INVALID_MX_RECORD  = 'emailAddressInvalidMxRecord';
     const DOT_ATOM           = 'emailAddressDotAtom';
@@ -49,7 +50,8 @@ class Zend_Validate_EmailAddress extends Zend_Validate_Abstract
      * @var array
      */
     protected $_messageTemplates = array(
-        self::INVALID            => "'%value%' is not a valid email address in the basic format local-part@hostname",
+        self::INVALID            => "Invalid type given, value should be a string",
+        self::INVALID_FORMAT     => "'%value%' is not a valid email address in the basic format local-part@hostname",
         self::INVALID_HOSTNAME   => "'%hostname%' is not a valid hostname for email address '%value%'",
         self::INVALID_MX_RECORD  => "'%hostname%' does not appear to have a valid MX record for the email address '%value%'",
         self::DOT_ATOM           => "'%localPart%' not matched against dot-atom format",
@@ -169,16 +171,20 @@ class Zend_Validate_EmailAddress extends Zend_Validate_Abstract
      */
     public function isValid($value)
     {
-        $valueString = (string) $value;
+        if (!is_string($value)) {
+            $this->_error(self::INVALID);
+            return false;
+        }
+
         $matches     = array();
         $length      = true;
 
-        $this->_setValue($valueString);
+        $this->_setValue($value);
 
         // Split email address up and disallow '..'
-        if ((strpos($valueString, '..') !== false) or
-            (!preg_match('/^(.+)@([^@]+)$/', $valueString, $matches))) {
-            $this->_error(self::INVALID);
+        if ((strpos($value, '..') !== false) or
+            (!preg_match('/^(.+)@([^@]+)$/', $value, $matches))) {
+            $this->_error(self::INVALID_FORMAT);
             return false;
         }
 

library/Zend/Validate/Float.php

@@ -37,13 +37,14 @@ require_once 'Zend/Locale/Format.php';
  */
 class Zend_Validate_Float extends Zend_Validate_Abstract
 {
-
+    const INVALID   = 'floatInvalid';
     const NOT_FLOAT = 'notFloat';
 
     /**
      * @var array
      */
     protected $_messageTemplates = array(
+        self::INVALID   => "Invalid type given, value should be float, string, or integer",
         self::NOT_FLOAT => "'%value%' does not appear to be a float"
     );
 
@@ -89,12 +90,15 @@ class Zend_Validate_Float extends Zend_Validate_Abstract
      */
     public function isValid($value)
     {
-        $valueString = (string) $value;
-
-        $this->_setValue($valueString);
+        if (!is_string($value) && !is_int($value) && !is_float($value)) {
+            $this->_error(self::INVALID);
+            return false;
+        }
 
+        $this->_setValue($value);
         try {
-            if (!Zend_Locale_Format::isFloat($value, array('locale' => $this->_locale))) {
+            if (!Zend_Locale_Format::isFloat($value, array('locale' => 'en')) &&
+                !Zend_Locale_Format::isFloat($value, array('locale' => $this->_locale))) {
                 $this->_error();
                 return false;
             }

library/Zend/Validate/Hostname.php

@@ -46,6 +46,7 @@ require_once 'Zend/Validate/Ip.php';
  */
 class Zend_Validate_Hostname extends Zend_Validate_Abstract
 {
+    const INVALID                 = 'hostnameInvalid';
     const IP_ADDRESS_NOT_ALLOWED  = 'hostnameIpAddressNotAllowed';
     const UNKNOWN_TLD             = 'hostnameUnknownTld';
     const INVALID_DASH            = 'hostnameDashCharacter';
@@ -60,6 +61,7 @@ class Zend_Validate_Hostname extends Zend_Validate_Abstract
      * @var array
      */
     protected $_messageTemplates = array(
+        self::INVALID                 => "Invalid type given, value should be a string",
         self::IP_ADDRESS_NOT_ALLOWED  => "'%value%' appears to be an IP address, but IP addresses are not allowed",
         self::UNKNOWN_TLD             => "'%value%' appears to be a DNS hostname but cannot match TLD against known list",
         self::INVALID_DASH            => "'%value%' appears to be a DNS hostname but contains a dash (-) in an invalid position",
@@ -409,13 +411,16 @@ class Zend_Validate_Hostname extends Zend_Validate_Abstract
      */
     public function isValid($value)
     {
-        $valueString = (string) $value;
+        if (!is_string($value)) {
+            $this->_error(self::INVALID);
+            return false;
+        }
 
-        $this->_setValue($valueString);
+        $this->_setValue($value);
 
         // Check input against IP address schema
-        if (preg_match('/^[0-9.a-e:.]*$/i', $valueString, $nothing) &&
-            $this->_ipValidator->setTranslator($this->getTranslator())->isValid($valueString)) {
+        if (preg_match('/^[0-9.a-e:.]*$/i', $value, $nothing) &&
+            $this->_ipValidator->setTranslator($this->getTranslator())->isValid($value)) {
             if (!($this->_allow & self::ALLOW_IP)) {
                 $this->_error(self::IP_ADDRESS_NOT_ALLOWED);
                 return false;
@@ -425,8 +430,8 @@ class Zend_Validate_Hostname extends Zend_Validate_Abstract
         }
 
         // Check input against DNS hostname schema
-        $domainParts = explode('.', $valueString);
-        if ((count($domainParts) > 1) && (strlen($valueString) >= 4) && (strlen($valueString) <= 254)) {
+        $domainParts = explode('.', $value);
+        if ((count($domainParts) > 1) && (strlen($value) >= 4) && (strlen($value) <= 254)) {
             $status = false;
 
             do {
@@ -539,7 +544,7 @@ class Zend_Validate_Hostname extends Zend_Validate_Abstract
 
         // Check input against local network name schema; last chance to pass validation
         $regexLocal = '/^(([a-zA-Z0-9\x2d]{1,63}\x2e)*[a-zA-Z0-9\x2d]{1,63}){1,254}$/';
-        $status = @preg_match($regexLocal, $valueString);
+        $status = @preg_match($regexLocal, $value);
         if (false === $status) {
             /**
              * Regex error

library/Zend/Validate/Int.php

@@ -44,7 +44,7 @@ class Zend_Validate_Int extends Zend_Validate_Abstract
      * @var array
      */
     protected $_messageTemplates = array(
-        self::INVALID   => "Invalid type given, value should be a string or a integer",
+        self::INVALID => "Invalid type given, value should be a string or a integer",
         self::NOT_INT => "'%value%' does not appear to be an integer"
     );
 
@@ -97,7 +97,8 @@ class Zend_Validate_Int extends Zend_Validate_Abstract
 
         $this->_setValue($value);
         try {
-            if (!Zend_Locale_Format::isInteger($value, array('locale' => $this->_locale))) {
+            if (!Zend_Locale_Format::isInteger($value, array('locale' => 'en')) &&
+                !Zend_Locale_Format::isInteger($value, array('locale' => $this->_locale))) {
                 $this->_error();
                 return false;
             }

library/Zend/Validate/Ip.php

@@ -32,12 +32,14 @@ require_once 'Zend/Validate/Abstract.php';
  */
 class Zend_Validate_Ip extends Zend_Validate_Abstract
 {
+    const INVALID        = 'ipInvalid';
     const NOT_IP_ADDRESS = 'notIpAddress';
 
     /**
      * @var array
      */
     protected $_messageTemplates = array(
+        self::INVALID        => "Invalid type given, value should be a string",
         self::NOT_IP_ADDRESS => "'%value%' does not appear to be a valid IP address"
     );
 
@@ -51,15 +53,18 @@ class Zend_Validate_Ip extends Zend_Validate_Abstract
      */
     public function isValid($value)
     {
-        $valueString = (string) $value;
+        if (!is_string($value)) {
+            $this->_error(self::INVALID);
+            return false;
+        }
 
-        $this->_setValue($valueString);
+        $this->_setValue($value);
 
-        if ((ip2long($valueString) === false) || (long2ip(ip2long($valueString)) !== $valueString)) {
+        if ((ip2long($value) === false) || (long2ip(ip2long($value)) !== $value)) {
             if (!function_exists('inet_pton')) {
                 $this->_error();
                 return false;
-            } else if ((@inet_pton($value) === false) ||(inet_ntop(@inet_pton($value)) !== $valueString)) {
+            } else if ((@inet_pton($value) === false) ||(inet_ntop(@inet_pton($value)) !== $value)) {
                 $this->_error();
                 return false;
             }

library/Zend/Validate/NotEmpty.php

@@ -32,12 +32,14 @@ require_once 'Zend/Validate/Abstract.php';
  */
 class Zend_Validate_NotEmpty extends Zend_Validate_Abstract
 {
+    const INVALID  = 'notEmptyInvalid';
     const IS_EMPTY = 'isEmpty';
 
     /**
      * @var array
      */
     protected $_messageTemplates = array(
+        self::INVALID  => "Invalid type given, value should be float, string, or integer",
         self::IS_EMPTY => "Value is required and can't be empty"
     );
 
@@ -51,7 +53,12 @@ class Zend_Validate_NotEmpty extends Zend_Validate_Abstract
      */
     public function isValid($value)
     {
-        $this->_setValue((string) $value);
+        if (!is_string($value) && !is_int($value) && !is_float($value) && !is_bool($value)) {
+            $this->_error(self::INVALID);
+            return false;
+        }
+
+        $this->_setValue($value);
 
         if (is_string($value)
             && (('' === $value)

library/Zend/Validate/Regex.php

@@ -35,13 +35,14 @@ require_once 'Zend/Validate/Abstract.php';
  */
 class Zend_Validate_Regex extends Zend_Validate_Abstract
 {
-
+    const INVALID   = 'regexInvalid';
     const NOT_MATCH = 'regexNotMatch';
 
     /**
      * @var array
      */
     protected $_messageTemplates = array(
+        self::INVALID   => "Invalid type given, value should be string, integer or float",
         self::NOT_MATCH => "'%value%' does not match against pattern '%pattern%'"
     );
 
@@ -103,17 +104,17 @@ class Zend_Validate_Regex extends Zend_Validate_Abstract
      */
     public function isValid($value)
     {
-        $valueString = (string) $value;
+        if (!is_string($value) && !is_int($value) && !is_float($value)) {
+            $this->_error(self::INVALID);
+            return false;
+        }
 
-        $this->_setValue($valueString);
+        $this->_setValue($value);
 
-        $status = @preg_match($this->_pattern, $valueString);
+        $status = @preg_match($this->_pattern, $value);
         if (false === $status) {
-            /**
-             * @see Zend_Validate_Exception
-             */
             require_once 'Zend/Validate/Exception.php';
-            throw new Zend_Validate_Exception("Internal error matching pattern '$this->_pattern' against value '$valueString'");
+            throw new Zend_Validate_Exception("Internal error matching pattern '$this->_pattern' against value '$value'");
         }
         if (!$status) {
             $this->_error();

tests/Zend/Validate/AlnumTest.php

@@ -175,4 +175,12 @@ class Zend_Validate_AlnumTest extends PHPUnit_Framework_TestCase
             );
         $this->assertThat($errors, $this->identicalTo($arrayExpected));
     }
+
+    /**
+     * @ZF-4352
+     */
+    public function testNonStringValidation()
+    {
+        $this->assertFalse($this->_validator->isValid(array(1 => 1)));
+    }
 }

tests/Zend/Validate/AlphaTest.php

@@ -122,4 +122,12 @@ class Zend_Validate_AlphaTest extends PHPUnit_Framework_TestCase
                 );
         }
     }
+
+    /**
+     * @ZF-4352
+     */
+    public function testNonStringValidation()
+    {
+        $this->assertFalse($this->_validator->isValid(array(1 => 1)));
+    }
 }

tests/Zend/Validate/DateTest.php

@@ -205,6 +205,14 @@ class Zend_Validate_DateTest extends PHPUnit_Framework_TestCase
     }
 
     /**
+     * @ZF-4352
+     */
+    public function testNonStringValidation()
+    {
+        $this->assertFalse($this->_validator->isValid(array(1 => 1)));
+    }
+
+    /**
      * Ignores a raised PHP error when in effect, but throws a flag to indicate an error occurred
      *
      * @param  integer $errno

tests/Zend/Validate/Db/NoRecordExistsTest.php

@@ -59,11 +59,15 @@ class Zend_Validate_Db_NoRecordExistsTest extends PHPUnit_Framework_TestCase
      */
     public function setUp()
     {
+        if (!extension_loaded('pdo_sqlite')) {
+            $this->markTestSkipped('No sqlite available');
+        }
+
         $this->_db = new Zend_Db_Adapter_Pdo_Sqlite(
             array('dbname' => 'test')
             );
 
-	Zend_Db_Table_Abstract::setDefaultAdapter($this->_db);
+        Zend_Db_Table_Abstract::setDefaultAdapter($this->_db);
 
         $createTable = 'CREATE TABLE [users] ( '
                    . '[id] INTEGER  NOT NULL PRIMARY KEY, '
@@ -153,7 +157,7 @@ class Zend_Validate_Db_NoRecordExistsTest extends PHPUnit_Framework_TestCase
     /**
      * Test that the class throws an exception if no adapter is provided
      * and no default is set.
-     * 
+     *
      * @return void
      */
     public function testThrowsExceptionWithNoAdapter()

tests/Zend/Validate/Db/RecordExistsTest.php

@@ -59,11 +59,15 @@ class Zend_Validate_Db_RecordExistsTest extends PHPUnit_Framework_TestCase
      */
     public function setUp()
     {
+        if (!extension_loaded('pdo_sqlite')) {
+            $this->markTestSkipped('No sqlite available');
+        }
+
         $this->_db = new Zend_Db_Adapter_Pdo_Sqlite(
             array('dbname' => 'test')
             );
 
-	    Zend_Db_Table_Abstract::setDefaultAdapter($this->_db);
+        Zend_Db_Table_Abstract::setDefaultAdapter($this->_db);
 
         $createTable = 'CREATE TABLE [users] ( '
                    . '[id] INTEGER  NOT NULL PRIMARY KEY, '
@@ -149,11 +153,11 @@ class Zend_Validate_Db_RecordExistsTest extends PHPUnit_Framework_TestCase
         $validator = new Zend_Validate_Db_RecordExists('users', 'field1', 'id != 1');
         $this->assertFalse($validator->isValid('nosuchvalue'));
     }
-    
+
     /**
      * Test that the class throws an exception if no adapter is provided
      * and no default is set.
-     * 
+     *
      * @return void
      */
     public function testThrowsExceptionWithNoAdapter()

tests/Zend/Validate/DigitsTest.php

@@ -145,4 +145,12 @@ class Zend_Validate_DigitsTest extends PHPUnit_Framework_TestCase
             );
         $this->assertThat($errors, $this->identicalTo($arrayExpected));
     }
+
+    /**
+     * @ZF-4352
+     */
+    public function testNonStringValidation()
+    {
+        $this->assertFalse($this->_validator->isValid(array(1 => 1)));
+    }
 }

tests/Zend/Validate/EmailAddressTest.php

@@ -409,4 +409,12 @@ class Zend_Validate_EmailAddressTest extends PHPUnit_Framework_TestCase
             $this->assertFalse($this->_validator->isValid($input));
         }
     }
+
+    /**
+     * @ZF-4352
+     */
+    public function testNonStringValidation()
+    {
+        $this->assertFalse($this->_validator->isValid(array(1 => 1)));
+    }
 }

tests/Zend/Validate/FloatTest.php

@@ -95,4 +95,12 @@ class Zend_Validate_FloatTest extends PHPUnit_Framework_TestCase
         $this->assertEquals('de', $this->_validator->getLocale());
         $this->assertEquals(true, $this->_validator->isValid('10,5'));
     }
+
+    /**
+     * @ZF-4352
+     */
+    public function testNonStringValidation()
+    {
+        $this->assertFalse($this->_validator->isValid(array(1 => 1)));
+    }
 }

tests/Zend/Validate/HostnameTest.php

@@ -333,4 +333,12 @@ class Zend_Validate_HostnameTest extends PHPUnit_Framework_TestCase
             }
         }
     }
+
+    /**
+     * @ZF-4352
+     */
+    public function testNonStringValidation()
+    {
+        $this->assertFalse($this->_validator->isValid(array(1 => 1)));
+    }
 }

tests/Zend/Validate/IpTest.php

@@ -107,4 +107,12 @@ class Zend_Validate_IpTest extends PHPUnit_Framework_TestCase
 
         $this->assertTrue($this->_validator->isValid('::127.0.0.1'));
     }
+
+    /**
+     * @ZF-4352
+     */
+    public function testNonStringValidation()
+    {
+        $this->assertFalse($this->_validator->isValid(array(1 => 1)));
+    }
 }

tests/Zend/Validate/NotEmptyTest.php

@@ -115,6 +115,14 @@ class Zend_Validate_NotEmptyTest extends PHPUnit_Framework_TestCase
     {
         $this->assertEquals(array(), $this->_validator->getMessages());
     }
+
+    /**
+     * @ZF-4352
+     */
+    public function testNonStringValidation()
+    {
+        $this->assertFalse($this->_validator->isValid(array(1 => 1)));
+    }
 }
 
 // Call Zend_Validate_NotEmptyTest::main() if this source file is executed directly.

tests/Zend/Validate/RegexTest.php

@@ -104,4 +104,13 @@ class Zend_Validate_RegexTest extends PHPUnit_Framework_TestCase
             $this->assertContains('Internal error matching pattern', $e->getMessage());
         }
     }
+
+    /**
+     * @ZF-4352
+     */
+    public function testNonStringValidation()
+    {
+        $validator = new Zend_Validate_Regex('/');
+        $this->assertFalse($validator->isValid(array(1 => 1)));
+    }
 }