[GENERIC] Zend_Validate_NotEmpty:

- new reworked implementation of Zend_Validate_NotEmpty
- see documentation for details
- 

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

documentation/manual/en/module_specs/Zend_Validate-NotEmpty.xml

@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect2 id="zend.validate.set.notempty">
+    <title>NotEmpty</title>
+
+    <para>
+        This validator allows you to validate if a given value is not empty. This is often useful
+        when working with form elements or other user input, where you can use it to ensure required
+        elements have values associated with them.
+    </para>
+
+    <sect3 id="zend.validate.set.notempty.default">
+        <title>Default behaviour for Zend_Validate_NotEmpty</title>
+
+        <para>
+            By default, this validator works differently than you would expect when you've worked
+            with <acronym>PHP</acronym>'s <functionname>empty()</functionname> function. In
+            particular, this validator will evaluate both the integer <emphasis>0</emphasis> and
+            string '<emphasis>0</emphasis>' as empty.
+        </para>
+
+        <programlisting language="php"><![CDATA[
+$valid = new Zend_Validate_NotEmpty();
+$value  = '';
+$result = $valid->isValid($value);
+// returns false
+]]></programlisting>
+
+        <note>
+            <title>Default behaviour differs from PHP</title>
+
+            <para>
+                Without providing configuration, <classname>Zend_Validate_NotEmpty</classname>'s
+                behaviour differs from <acronym>PHP</acronym>.
+            </para>
+        </note>
+    </sect3>
+
+    <sect3 id="zend.validate.set.notempty.types">
+        <title>Changing behaviour for Zend_Validate_NotEmpty</title>
+
+        <para>
+            Some projects have differing opinions of what is considered an "empty" value: a string
+            with only whitespace might be considered empty, or <integer>0</integer> may be
+            considered non-empty (particularly for boolean sequences). To accomodate differing
+            needs, <classname>Zend_Validate_NotEmpty</classname> allows you to configure which types
+            should be validated as empty and which not.
+        </para>
+
+        <para>
+            The following types can be handled:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <emphasis>boolean</emphasis>: Returns <constant>FALSE</constant> when the
+                    boolean value is <constant>FALSE</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>integer</emphasis>: Returns <constant>FALSE</constant> when an integer
+                    <emphasis>0</emphasis> value is given. Per default this validation is not
+                    activated and returns <constant>TRUE</constant> on any integer values.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>float</emphasis>: Returns <constant>FALSE</constant> when an float
+                    <emphasis>0.0</emphasis> value is given. Per default this validation is not
+                    activated and returns <constant>TRUE</constant> on any float values.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>string</emphasis>: Returns <constant>FALSE</constant> when an empty
+                    string <emphasis>''</emphasis> is given.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>zero</emphasis>: Returns <constant>FALSE</constant> when the single
+                    character zero (<emphasis>'0'</emphasis>) is given.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>empty_array</emphasis>: Returns <constant>FALSE</constant> when an
+                    empty <emphasis>array</emphasis> is given.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>null</emphasis>: Returns <constant>FALSE</constant> when an
+                    <constant>NULL</constant> value is given.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>php</emphasis>: Returns <constant>FALSE</constant> on the same reasons
+                    where <acronym>PHP</acronym> method <methodname>empty()</methodname> would
+                    return <constant>TRUE</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>space</emphasis>: Returns <constant>FALSE</constant> when an string
+                    is given which contains only whitespaces.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>all</emphasis>: Returns <constant>FALSE</constant> on all above types.
+                </para>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            All other given values will return <constant>TRUE</constant> per default.
+        </para>
+
+        <para>
+            There are several ways to select which of the above types are validated. You can give
+            one or multiple types and add them, you can give an array, you can use constants, or you
+            can give a textual string. See the following examples:
+        </para>
+
+        <programlisting language="php"><![CDATA[
+// Returns false on 0
+$validator = new Zend_Validate_NotEmpty(Zend_Validate_NotEmpty::INTEGER);
+
+// Returns false on 0 or '0'
+$validator = new Zend_Validate_NotEmpty(
+    Zend_Validate_NotEmpty::INTEGER + Zend_NotEmpty::ZERO
+);
+
+// Returns false on 0 or '0'
+$validator = new Zend_Validate_NotEmpty(array(
+    Zend_Validate_NotEmpty::INTEGER,
+    Zend_Validate_NotEmpty::ZERO
+));
+
+// Returns false on 0 or '0'
+$validator = new Zend_Validate_NotEmpty(array(
+    'integer',
+    'zero',
+));
+]]></programlisting>
+
+        <para>
+            You can also provide an instance of <classname>Zend_Config</classname> to set the
+            desired types. To set types after instantiation, use the
+            <methodname>setType()</methodname> method.
+        </para>
+    </sect3>
+</sect2>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/en/module_specs/Zend_Validate-Set.xml

@@ -187,13 +187,7 @@ if ($validator->isValid($iban)) {
         </para>
     </sect2>
 
-    <sect2 id="zend.validate.set.not_empty">
-        <title>NotEmpty</title>
-        <para>
-            Returns <constant>TRUE</constant> if and only if <varname>$value</varname> is not an empty value.
-        </para>
-    </sect2>
-
+    <xi:include href="Zend_Validate-NotEmpty.xml" />
     <xi:include href="Zend_Validate-PostCode.xml" />
 
     <sect2 id="zend.validate.set.regex">

library/Zend/Validate/NotEmpty.php

@@ -32,9 +32,33 @@ require_once 'Zend/Validate/Abstract.php';
  */
 class Zend_Validate_NotEmpty extends Zend_Validate_Abstract
 {
+    const BOOLEAN      = 1;
+    const INTEGER      = 2;
+    const FLOAT        = 4;
+    const STRING       = 8;
+    const ZERO         = 16;
+    const EMPTY_ARRAY  = 32;
+    const NULL         = 64;
+    const PHP          = 127;
+    const SPACE        = 128;
+    const ALL          = 255;
+
     const INVALID  = 'notEmptyInvalid';
     const IS_EMPTY = 'isEmpty';
 
+    protected $_constants = array(
+        self::BOOLEAN      => 'boolean',
+        self::INTEGER      => 'integer',
+        self::FLOAT        => 'float',
+        self::STRING       => 'string',
+        self::ZERO         => 'zero',
+        self::EMPTY_ARRAY  => 'array',
+        self::NULL         => 'null',
+        self::PHP          => 'php',
+        self::SPACE        => 'space',
+        self::ALL          => 'all'
+    );
+
     /**
      * @var array
      */
@@ -44,6 +68,80 @@ class Zend_Validate_NotEmpty extends Zend_Validate_Abstract
     );
 
     /**
+     * Internal type to detect
+     *
+     * @var integer
+     */
+    protected $_type = 237;
+
+    /**
+     * Constructor
+     *
+     * @param string|array|Zend_Config $options OPTIONAL
+     */
+    public function __construct($options = null)
+    {
+        if ($options instanceof Zend_Config) {
+            $options = $options->toArray();
+        } else if (!is_array($options)) {
+            $options = func_get_args();
+            $temp    = array();
+            if (!empty($options)) {
+                $temp['type'] = array_shift($options);
+            }
+
+            $options = $temp;
+        }
+
+        if (is_array($options) && array_key_exists('type', $options)) {
+            $this->setType($options['type']);
+        }
+    }
+
+    /**
+     * Returns the set types
+     *
+     * @return array
+     */
+    public function getType()
+    {
+        return $this->_type;
+    }
+
+    /**
+     * Set the types
+     *
+     * @param  integer|array $type
+     * @throws Zend_Validate_Exception
+     * @return Zend_Validate_NotEmpty
+     */
+    public function setType($type = null)
+    {
+        if (is_array($type)) {
+            $detected = 0;
+            foreach($type as $value) {
+                if (is_int($value)) {
+                    $detected += $value;
+                } else if (in_array($value, $this->_constants)) {
+                    $detected += array_search($value, $this->_constants);
+                }
+            }
+
+            $type = $detected;
+        } else if (is_string($type) && in_array($type, $this->_constants)) {
+            $type = array_search($type, $this->_constants);
+        }
+
+        if (!is_int($type) || ($type < 0) || ($type > self::ALL)) {
+            require_once 'Zend/Validate/Exception.php';
+            throw new Zend_Validate_Exception('Unknown type');
+        }
+
+        $this->_type = $type;
+        return $this;
+    }
+
+    /**
      * Defined by Zend_Validate_Interface
      *
      * Returns true if and only if $value is not an empty value.
@@ -59,21 +157,80 @@ class Zend_Validate_NotEmpty extends Zend_Validate_Abstract
             return false;
         }
 
+        $type    = $this->getType();
         $this->_setValue($value);
-        if (is_string($value)
-            && (('' === $value)
-                || preg_match('/^\s+$/s', $value))
-        ) {
-            $this->_error(self::IS_EMPTY);
-            return false;
-        } elseif (!is_string($value) && empty($value)) {
-            if (!is_int($value)) {
-                $this->_error(self::IS_EMPTY);
+
+        // SPACE ('   ')
+        if ($type >= self::SPACE) {
+            $type -= self::SPACE;
+            if (is_string($value) && (preg_match('/^\s+$/s', $value))) {
+                $this->_error(self::INVALID);
+                return false;
+            }
+        }
+
+        // NULL (null)
+        if ($type >= self::NULL) {
+            $type -= self::NULL;
+            if (is_null($value)) {
+                $this->_error(self::INVALID);
+                return false;
+            }
+        }
+
+        // EMPTY_ARRAY (array())
+        if ($type >= self::EMPTY_ARRAY) {
+            $type -= self::EMPTY_ARRAY;
+            if (is_array($value) && ($value == array())) {
+                $this->_error(self::INVALID);
+                return false;
+            }
+        }
+
+        // ZERO ('0')
+        if ($type >= self::ZERO) {
+            $type -= self::ZERO;
+            if (is_string($value) && ($value == '0')) {
+                $this->_error(self::INVALID);
                 return false;
             }
         }
 
+        // STRING ('')
+        if ($type >= self::STRING) {
+            $type -= self::STRING;
+            if (is_string($value) && ($value == '')) {
+                $this->_error(self::INVALID);
+                return false;
+            }
+        }
+
+        // FLOAT (0.0)
+        if ($type >= self::FLOAT) {
+            $type -= self::FLOAT;
+            if (is_float($value) && ($value == 0.0)) {
+                $this->_error(self::INVALID);
+                return false;
+            }
+        }
+
+        // INTEGER (0)
+        if ($type >= self::INTEGER) {
+            $type -= self::INTEGER;
+            if (is_int($value) && ($value == 0)) {
+                $this->_error(self::INVALID);
+                return false;
+            }
+        }
+
+        // BOOLEAN (false)
+        if ($type >= self::BOOLEAN) {
+            $type -= self::BOOLEAN;
+            if (is_bool($value)) {
+                return $value;
+            }
+        }
+
         return true;
     }
-
 }

tests/Zend/Validate/NotEmptyTest.php

@@ -106,6 +106,435 @@ class Zend_Validate_NotEmptyTest extends PHPUnit_Framework_TestCase
     }
 
     /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyBoolean()
+    {
+        $this->_validator->setType(Zend_Validate_NotEmpty::BOOLEAN);
+        $this->assertFalse($this->_validator->isValid(false));
+        $this->assertTrue($this->_validator->isValid(true));
+        $this->assertTrue($this->_validator->isValid(0));
+        $this->assertTrue($this->_validator->isValid(1));
+        $this->assertTrue($this->_validator->isValid(0.0));
+        $this->assertTrue($this->_validator->isValid(1.0));
+        $this->assertTrue($this->_validator->isValid(''));
+        $this->assertTrue($this->_validator->isValid('abc'));
+        $this->assertTrue($this->_validator->isValid('0'));
+        $this->assertTrue($this->_validator->isValid('1'));
+        $this->assertTrue($this->_validator->isValid(array()));
+        $this->assertTrue($this->_validator->isValid(array('xxx')));
+        $this->assertTrue($this->_validator->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyInteger()
+    {
+        $this->_validator->setType(Zend_Validate_NotEmpty::INTEGER);
+        $this->assertTrue($this->_validator->isValid(false));
+        $this->assertTrue($this->_validator->isValid(true));
+        $this->assertFalse($this->_validator->isValid(0));
+        $this->assertTrue($this->_validator->isValid(1));
+        $this->assertTrue($this->_validator->isValid(0.0));
+        $this->assertTrue($this->_validator->isValid(1.0));
+        $this->assertTrue($this->_validator->isValid(''));
+        $this->assertTrue($this->_validator->isValid('abc'));
+        $this->assertTrue($this->_validator->isValid('0'));
+        $this->assertTrue($this->_validator->isValid('1'));
+        $this->assertTrue($this->_validator->isValid(array()));
+        $this->assertTrue($this->_validator->isValid(array('xxx')));
+        $this->assertTrue($this->_validator->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyFloat()
+    {
+        $this->_validator->setType(Zend_Validate_NotEmpty::FLOAT);
+        $this->assertTrue($this->_validator->isValid(false));
+        $this->assertTrue($this->_validator->isValid(true));
+        $this->assertTrue($this->_validator->isValid(0));
+        $this->assertTrue($this->_validator->isValid(1));
+        $this->assertFalse($this->_validator->isValid(0.0));
+        $this->assertTrue($this->_validator->isValid(1.0));
+        $this->assertTrue($this->_validator->isValid(''));
+        $this->assertTrue($this->_validator->isValid('abc'));
+        $this->assertTrue($this->_validator->isValid('0'));
+        $this->assertTrue($this->_validator->isValid('1'));
+        $this->assertTrue($this->_validator->isValid(array()));
+        $this->assertTrue($this->_validator->isValid(array('xxx')));
+        $this->assertTrue($this->_validator->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyString()
+    {
+        $this->_validator->setType(Zend_Validate_NotEmpty::STRING);
+        $this->assertTrue($this->_validator->isValid(false));
+        $this->assertTrue($this->_validator->isValid(true));
+        $this->assertTrue($this->_validator->isValid(0));
+        $this->assertTrue($this->_validator->isValid(1));
+        $this->assertTrue($this->_validator->isValid(0.0));
+        $this->assertTrue($this->_validator->isValid(1.0));
+        $this->assertFalse($this->_validator->isValid(''));
+        $this->assertTrue($this->_validator->isValid('abc'));
+        $this->assertTrue($this->_validator->isValid('0'));
+        $this->assertTrue($this->_validator->isValid('1'));
+        $this->assertTrue($this->_validator->isValid(array()));
+        $this->assertTrue($this->_validator->isValid(array('xxx')));
+        $this->assertTrue($this->_validator->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyZero()
+    {
+        $this->_validator->setType(Zend_Validate_NotEmpty::ZERO);
+        $this->assertTrue($this->_validator->isValid(false));
+        $this->assertTrue($this->_validator->isValid(true));
+        $this->assertTrue($this->_validator->isValid(0));
+        $this->assertTrue($this->_validator->isValid(1));
+        $this->assertTrue($this->_validator->isValid(0.0));
+        $this->assertTrue($this->_validator->isValid(1.0));
+        $this->assertTrue($this->_validator->isValid(''));
+        $this->assertTrue($this->_validator->isValid('abc'));
+        $this->assertFalse($this->_validator->isValid('0'));
+        $this->assertTrue($this->_validator->isValid('1'));
+        $this->assertTrue($this->_validator->isValid(array()));
+        $this->assertTrue($this->_validator->isValid(array('xxx')));
+        $this->assertTrue($this->_validator->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyArray()
+    {
+        $this->_validator->setType(Zend_Validate_NotEmpty::EMPTY_ARRAY);
+        $this->assertTrue($this->_validator->isValid(false));
+        $this->assertTrue($this->_validator->isValid(true));
+        $this->assertTrue($this->_validator->isValid(0));
+        $this->assertTrue($this->_validator->isValid(1));
+        $this->assertTrue($this->_validator->isValid(0.0));
+        $this->assertTrue($this->_validator->isValid(1.0));
+        $this->assertTrue($this->_validator->isValid(''));
+        $this->assertTrue($this->_validator->isValid('abc'));
+        $this->assertTrue($this->_validator->isValid('0'));
+        $this->assertTrue($this->_validator->isValid('1'));
+        $this->assertFalse($this->_validator->isValid(array()));
+        $this->assertTrue($this->_validator->isValid(array('xxx')));
+        $this->assertTrue($this->_validator->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyNull()
+    {
+        $this->_validator->setType(Zend_Validate_NotEmpty::NULL);
+        $this->assertTrue($this->_validator->isValid(false));
+        $this->assertTrue($this->_validator->isValid(true));
+        $this->assertTrue($this->_validator->isValid(0));
+        $this->assertTrue($this->_validator->isValid(1));
+        $this->assertTrue($this->_validator->isValid(0.0));
+        $this->assertTrue($this->_validator->isValid(1.0));
+        $this->assertTrue($this->_validator->isValid(''));
+        $this->assertTrue($this->_validator->isValid('abc'));
+        $this->assertTrue($this->_validator->isValid('0'));
+        $this->assertTrue($this->_validator->isValid('1'));
+        $this->assertTrue($this->_validator->isValid(array()));
+        $this->assertTrue($this->_validator->isValid(array('xxx')));
+        $this->assertFalse($this->_validator->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyPHP()
+    {
+        $this->_validator->setType(Zend_Validate_NotEmpty::PHP);
+        $this->assertFalse($this->_validator->isValid(false));
+        $this->assertTrue($this->_validator->isValid(true));
+        $this->assertFalse($this->_validator->isValid(0));
+        $this->assertTrue($this->_validator->isValid(1));
+        $this->assertFalse($this->_validator->isValid(0.0));
+        $this->assertTrue($this->_validator->isValid(1.0));
+        $this->assertFalse($this->_validator->isValid(''));
+        $this->assertTrue($this->_validator->isValid('abc'));
+        $this->assertFalse($this->_validator->isValid('0'));
+        $this->assertTrue($this->_validator->isValid('1'));
+        $this->assertFalse($this->_validator->isValid(array()));
+        $this->assertTrue($this->_validator->isValid(array('xxx')));
+        $this->assertFalse($this->_validator->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlySpace()
+    {
+        $this->_validator->setType(Zend_Validate_NotEmpty::SPACE);
+        $this->assertTrue($this->_validator->isValid(false));
+        $this->assertTrue($this->_validator->isValid(true));
+        $this->assertTrue($this->_validator->isValid(0));
+        $this->assertTrue($this->_validator->isValid(1));
+        $this->assertTrue($this->_validator->isValid(0.0));
+        $this->assertTrue($this->_validator->isValid(1.0));
+        $this->assertTrue($this->_validator->isValid(''));
+        $this->assertTrue($this->_validator->isValid('abc'));
+        $this->assertTrue($this->_validator->isValid('0'));
+        $this->assertTrue($this->_validator->isValid('1'));
+        $this->assertTrue($this->_validator->isValid(array()));
+        $this->assertTrue($this->_validator->isValid(array('xxx')));
+        $this->assertTrue($this->_validator->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyAll()
+    {
+        $this->_validator->setType(Zend_Validate_NotEmpty::ALL);
+        $this->assertFalse($this->_validator->isValid(false));
+        $this->assertTrue($this->_validator->isValid(true));
+        $this->assertFalse($this->_validator->isValid(0));
+        $this->assertTrue($this->_validator->isValid(1));
+        $this->assertFalse($this->_validator->isValid(0.0));
+        $this->assertTrue($this->_validator->isValid(1.0));
+        $this->assertFalse($this->_validator->isValid(''));
+        $this->assertTrue($this->_validator->isValid('abc'));
+        $this->assertFalse($this->_validator->isValid('0'));
+        $this->assertTrue($this->_validator->isValid('1'));
+        $this->assertFalse($this->_validator->isValid(array()));
+        $this->assertTrue($this->_validator->isValid(array('xxx')));
+        $this->assertFalse($this->_validator->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testArrayConstantNotation()
+    {
+        $filter = new Zend_Validate_NotEmpty(
+            array(
+                'type' => array(
+                    Zend_Validate_NotEmpty::ZERO,
+                    Zend_Validate_NotEmpty::STRING,
+                    Zend_Validate_NotEmpty::BOOLEAN
+                )
+            )
+        );
+
+        $this->assertFalse($filter->isValid(false));
+        $this->assertTrue($filter->isValid(true));
+        $this->assertTrue($filter->isValid(0));
+        $this->assertTrue($filter->isValid(1));
+        $this->assertTrue($filter->isValid(0.0));
+        $this->assertTrue($filter->isValid(1.0));
+        $this->assertFalse($filter->isValid(''));
+        $this->assertTrue($filter->isValid('abc'));
+        $this->assertFalse($filter->isValid('0'));
+        $this->assertTrue($filter->isValid('1'));
+        $this->assertTrue($filter->isValid(array()));
+        $this->assertTrue($filter->isValid(array('xxx')));
+        $this->assertTrue($filter->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testArrayConfigNotation()
+    {
+        $filter = new Zend_Validate_NotEmpty(
+            array(
+                'type' => array(
+                    Zend_Validate_NotEmpty::ZERO,
+                    Zend_Validate_NotEmpty::STRING,
+                    Zend_Validate_NotEmpty::BOOLEAN),
+                'test' => false
+            )
+        );
+
+        $this->assertFalse($filter->isValid(false));
+        $this->assertTrue($filter->isValid(true));
+        $this->assertTrue($filter->isValid(0));
+        $this->assertTrue($filter->isValid(1));
+        $this->assertTrue($filter->isValid(0.0));
+        $this->assertTrue($filter->isValid(1.0));
+        $this->assertFalse($filter->isValid(''));
+        $this->assertTrue($filter->isValid('abc'));
+        $this->assertFalse($filter->isValid('0'));
+        $this->assertTrue($filter->isValid('1'));
+        $this->assertTrue($filter->isValid(array()));
+        $this->assertTrue($filter->isValid(array('xxx')));
+        $this->assertTrue($filter->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testMultiConstantNotation()
+    {
+        $filter = new Zend_Validate_NotEmpty(
+            Zend_Validate_NotEmpty::ZERO + Zend_Validate_NotEmpty::STRING + Zend_Validate_NotEmpty::BOOLEAN
+        );
+
+        $this->assertFalse($filter->isValid(false));
+        $this->assertTrue($filter->isValid(true));
+        $this->assertTrue($filter->isValid(0));
+        $this->assertTrue($filter->isValid(1));
+        $this->assertTrue($filter->isValid(0.0));
+        $this->assertTrue($filter->isValid(1.0));
+        $this->assertFalse($filter->isValid(''));
+        $this->assertTrue($filter->isValid('abc'));
+        $this->assertFalse($filter->isValid('0'));
+        $this->assertTrue($filter->isValid('1'));
+        $this->assertTrue($filter->isValid(array()));
+        $this->assertTrue($filter->isValid(array('xxx')));
+        $this->assertTrue($filter->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testStringNotation()
+    {
+        $filter = new Zend_Validate_NotEmpty(
+            array(
+                'type' => array('zero', 'string', 'boolean')
+            )
+        );
+
+        $this->assertFalse($filter->isValid(false));
+        $this->assertTrue($filter->isValid(true));
+        $this->assertTrue($filter->isValid(0));
+        $this->assertTrue($filter->isValid(1));
+        $this->assertTrue($filter->isValid(0.0));
+        $this->assertTrue($filter->isValid(1.0));
+        $this->assertFalse($filter->isValid(''));
+        $this->assertTrue($filter->isValid('abc'));
+        $this->assertFalse($filter->isValid('0'));
+        $this->assertTrue($filter->isValid('1'));
+        $this->assertTrue($filter->isValid(array()));
+        $this->assertTrue($filter->isValid(array('xxx')));
+        $this->assertTrue($filter->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testSingleStringNotation()
+    {
+        $filter = new Zend_Validate_NotEmpty(
+            'boolean'
+        );
+
+        $this->assertFalse($filter->isValid(false));
+        $this->assertTrue($filter->isValid(true));
+        $this->assertTrue($filter->isValid(0));
+        $this->assertTrue($filter->isValid(1));
+        $this->assertTrue($filter->isValid(0.0));
+        $this->assertTrue($filter->isValid(1.0));
+        $this->assertTrue($filter->isValid(''));
+        $this->assertTrue($filter->isValid('abc'));
+        $this->assertTrue($filter->isValid('0'));
+        $this->assertTrue($filter->isValid('1'));
+        $this->assertTrue($filter->isValid(array()));
+        $this->assertTrue($filter->isValid(array('xxx')));
+        $this->assertTrue($filter->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testConfigObject()
+    {
+        require_once 'Zend/Config.php';
+        $options = array('type' => 'all');
+        $config  = new Zend_Config($options);
+
+        $filter = new Zend_Validate_NotEmpty(
+            $config
+        );
+
+        $this->assertFalse($filter->isValid(false));
+        $this->assertTrue($filter->isValid(true));
+        $this->assertFalse($filter->isValid(0));
+        $this->assertTrue($filter->isValid(1));
+        $this->assertFalse($filter->isValid(0.0));
+        $this->assertTrue($filter->isValid(1.0));
+        $this->assertFalse($filter->isValid(''));
+        $this->assertTrue($filter->isValid('abc'));
+        $this->assertFalse($filter->isValid('0'));
+        $this->assertTrue($filter->isValid('1'));
+        $this->assertFalse($filter->isValid(array()));
+        $this->assertTrue($filter->isValid(array('xxx')));
+        $this->assertFalse($filter->isValid(null));
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testSettingFalseType()
+    {
+        try {
+            $this->_validator->setType(true);
+            $this->fail();
+        } catch (Zend_Exception $e) {
+            $this->assertContains('Unknown', $e->getMessage());
+        }
+    }
+
+    /**
+     * Ensures that the validator follows expected behavior
+     *
+     * @return void
+     */
+    public function testGetType()
+    {
+        $this->assertEquals(237, $this->_validator->getType());
+    }
+
+    /**
      * @see ZF-3236
      */
     public function testStringWithZeroShouldNotBeTreatedAsEmpty()