[PROMOTE] Zend_Filter_Boolean

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

documentation/manual/en/module_specs/Zend_Filter-Boolean.xml

@@ -0,0 +1,331 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect2 id="zend.filter.set.boolean">
+    <title>Boolean</title>
+
+    <para>
+        This filter changes a given input to be a <constant>BOOLEAN</constant> value. This is often
+        useful when working with databases or when processing form values.
+    </para>
+
+    <sect3 id="zend.filter.set.boolean.default">
+        <title>Default behaviour for Zend_Filter_Boolean</title>
+
+        <para>
+            By default, this filter works by casting the input to a <constant>BOOLEAN</constant>
+            value; in other words, it operates in a similar fashion to calling <command>(boolean)
+            $value</command>.
+        </para>
+
+        <programlisting language="php"><![CDATA[
+$filter = new Zend_Filter_Boolean();
+$value  = '';
+$result = $filter->filter($value);
+// returns false
+]]></programlisting>
+
+        <para>
+            This means that without providing any configuration,
+            <classname>Zend_Filter_Boolean</classname> accepts all input types and returns a
+            <constant>BOOLEAN</constant> just as you would get by type casting to
+            <constant>BOOLEAN</constant>.
+        </para>
+    </sect3>
+
+    <sect3 id="zend.filter.set.boolean.types">
+        <title>Changing behaviour for Zend_Filter_Boolean</title>
+
+        <para>
+            Sometimes casting with <command>(boolean)</command> will not suffice.
+            <classname>Zend_Filter_Boolean</classname> allows you to configure specific types to
+            convert, as well as which to omit.
+        </para>
+
+        <para>
+            The following types can be handled:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <emphasis>boolean</emphasis>: Returns a boolean value as is.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>integer</emphasis>: Converts an integer <emphasis>0</emphasis> value
+                    to <constant>FALSE</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>float</emphasis>: Converts a float <emphasis>0.0</emphasis> value
+                    to <constant>FALSE</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>string</emphasis>: Converts an empty string <emphasis>''</emphasis> to
+                    <constant>FALSE</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>zero</emphasis>: Converts a string containing the single character
+                    zero (<emphasis>'0'</emphasis>) to <constant>FALSE</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>empty_array</emphasis>: Converts an empty <emphasis>array</emphasis>
+                    to <constant>FALSE</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>null</emphasis>: Converts a <constant>NULL</constant> value
+                    to <constant>FALSE</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>php</emphasis>: Converts values according to <acronym>PHP</acronym>
+                    when casting them to <constant>BOOLEAN</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>false_string</emphasis>: Converts a string containing the word "false"
+                    to a boolean <constant>FALSE</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>yes</emphasis>: Converts a localized string which contains the word
+                    "no" to <constant>FALSE</constant>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>all</emphasis>: Converts all above types to
+                    <constant>BOOLEAN</constant>.
+                </para>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            All other given values will return <constant>TRUE</constant> by default.
+        </para>
+
+        <para>
+            There are several ways to select which of the above types are filtered. 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[
+// converts 0 to false
+$filter = new Zend_Filter_Boolean(Zend_Filter_Boolean::INTEGER);
+
+// converts 0 and '0' to false
+$filter = new Zend_Filter_Boolean(
+    Zend_Filter_Boolean::INTEGER + Zend_Filter_Boolean::ZERO
+);
+
+// converts 0 and '0' to false
+$filter = new Zend_Filter_Boolean(array(
+    'type' => array(
+        Zend_Filter_Boolean::INTEGER,
+        Zend_Filter_Boolean::ZERO,
+    ),
+));
+
+// converts 0 and '0' to false
+$filter = new Zend_Filter_Boolean(array(
+    'type' => array(
+        'integer',
+        'zero',
+    ),
+));
+]]></programlisting>
+
+        <para>
+            You can also give 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>
+
+    <sect3 id="zend.filter.set.boolean.localized">
+        <title>Localized booleans</title>
+
+        <para>
+            As mentioned previously, <classname>Zend_Filter_Boolean</classname> can also recognise
+            localized "yes" and "no" strings. This means that you can ask your customer in a form
+            for "yes" or "no" within his native language and
+            <classname>Zend_Filter_Boolean</classname> will convert the response to the appropriate
+            boolean value.
+        </para>
+
+        <para>
+            To set the desired locale, you can either use the <property>locale</property> option, or
+            the method <methodname>setLocale()</methodname>.
+        </para>
+
+        <programlisting language="php"><![CDATA[
+$filter = new Zend_Filter_Boolean(array(
+    'type'   => Zend_Filter_Boolean::ALL, 
+    'locale' => 'de',
+));
+
+// returns false
+echo $filter->filter('nein');
+
+$filter->setLocale('en');
+
+// returns true
+$filter->filter('yes');
+]]></programlisting>
+    </sect3>
+
+    <sect3 id="zend.filter.set.boolean.casting">
+        <title>Disable casting</title>
+
+        <para>
+            Sometimes it is necessary to recognise only <constant>TRUE</constant> or
+            <constant>FALSE</constant> and return all other values without changes.
+            <classname>Zend_Filter_Boolean</classname> allows you to do this by setting the
+            <property>casting</property> option to <constant>FALSE</constant>.
+        </para>
+
+        <para>
+            In this case <classname>Zend_Filter_Boolean</classname> will work as described in the
+            following table, which shows which values return true or false. All other given values
+            are returned without change when <property>casting</property> is set to
+            <constant>FALSE</constant>
+        </para>
+
+        <table id="zend.filter.set.boolean.casting.table">
+            <title>Usage without casting</title>
+            <tgroup cols="3">
+                <thead>
+                    <row>
+                        <entry>Type</entry>
+
+                        <entry>True</entry>
+
+                        <entry>False</entry>
+                    </row>
+                </thead>
+
+                <tbody>
+                    <row>
+                        <entry>Zend_Filter_Boolean::BOOLEAN</entry>
+
+                        <entry><constant>TRUE</constant></entry>
+
+                        <entry><constant>FALSE</constant></entry>
+                    </row>
+
+                    <row>
+                        <entry>Zend_Filter_Boolean::INTEGER</entry>
+
+                        <entry>0</entry>
+
+                        <entry>1</entry>
+                    </row>
+
+                    <row>
+                        <entry>Zend_Filter_Boolean::FLOAT</entry>
+
+                        <entry>0.0</entry>
+
+                        <entry>1.0</entry>
+                    </row>
+
+                    <row>
+                        <entry>Zend_Filter_Boolean::STRING</entry>
+
+                        <entry>""</entry>
+
+                        <entry />
+                    </row>
+
+                    <row>
+                        <entry>Zend_Filter_Boolean::ZERO</entry>
+
+                        <entry>"0"</entry>
+
+                        <entry>"1"</entry>
+                    </row>
+
+                    <row>
+                        <entry>Zend_Filter_Boolean::EMPTY_ARRAY</entry>
+
+                        <entry>array()</entry>
+
+                        <entry />
+                    </row>
+
+                    <row>
+                        <entry>Zend_Filter_Boolean::NULL</entry>
+
+                        <entry><constant>NULL</constant></entry>
+
+                        <entry />
+                    </row>
+
+                    <row>
+                        <entry>Zend_Filter_Boolean::FALSE_STRING</entry>
+
+                        <entry>"false"</entry>
+
+                        <entry>"true"</entry>
+                    </row>
+
+                    <row>
+                        <entry>Zend_Filter_Boolean::YES</entry>
+
+                        <entry>localized "yes"</entry>
+
+                        <entry>localized "no"</entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
+
+        <para>
+            The following example shows the behaviour when changing the <property>casting</property>
+            option:
+        </para>
+
+        <programlisting language="php"><![CDATA[
+$filter = new Zend_Filter_Boolean(array(
+    'type'    => Zend_Filter_Boolean::ALL, 
+    'casting' => false,
+));
+
+// returns false
+echo $filter->filter(0);
+
+// returns true
+echo $filter->filter(1);
+
+// returns the value
+echo $filter->filter(2);
+]]></programlisting>
+    </sect3>
+</sect2>
+<!--
+vim:se ts=4 sw=4 et:
+-->

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

@@ -42,6 +42,7 @@
         </para>
     </sect2>
 
+    <xi:include href="Zend_Filter-Boolean.xml" />
     <xi:include href="Zend_Filter-Callback.xml" />
     <xi:include href="Zend_Filter-Compress.xml" />
     <xi:include href="Zend_Filter-Decryption.xml" />

library/Zend/Filter/Boolean.php

@@ -0,0 +1,375 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Filter
+ * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id:$
+ */
+
+/**
+ * @see Zend_Filter_Interface
+ */
+require_once 'Zend/Filter/Interface.php';
+
+/**
+ * @category   Zend
+ * @package    Zend_Filter
+ * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Filter_Boolean implements Zend_Filter_Interface
+{
+    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 FALSE_STRING = 128;
+    const YES          = 256;
+    const ALL          = 511;
+
+    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::FALSE_STRING => 'false',
+        self::YES          => 'yes',
+        self::ALL          => 'all',
+    );
+
+    /**
+     * Internal type to detect
+     *
+     * @var integer
+     */
+    protected $_type = self::PHP;
+
+    /**
+     * Internal locale
+     *
+     * @var array
+     */
+    protected $_locale = array('auto');
+
+    /**
+     * Internal mode
+     *
+     * @var boolean
+     */
+    protected $_casting = true;
+
+    /**
+     * Constructor
+     *
+     * @param string|array|Zend_Config $options OPTIONAL
+     */
+    public function __construct($options = null)
+    {
+        if ($options instanceof Zend_Config) {
+            $options = $options->toArray();
+        } elseif (!is_array($options)) {
+            $options = func_get_args();
+            $temp    = array();
+            if (!empty($options)) {
+                $temp['type'] = array_shift($options);
+            }
+
+            if (!empty($options)) {
+                $temp['casting'] = array_shift($options);
+            }
+
+            if (!empty($options)) {
+                $temp['locale'] = array_shift($options);
+            }
+
+            $options = $temp;
+        }
+
+        if (array_key_exists('type', $options)) {
+            $this->setType($options['type']);
+        }
+
+        if (array_key_exists('casting', $options)) {
+            $this->setCasting($options['casting']);
+        }
+
+        if (array_key_exists('locale', $options)) {
+            $this->setLocale($options['locale']);
+        }
+    }
+
+    /**
+     * Returns the set null types
+     *
+     * @return int
+     */
+    public function getType()
+    {
+        return $this->_type;
+    }
+
+    /**
+     * Set the null types
+     *
+     * @param  integer|array $type
+     * @throws Zend_Filter_Exception
+     * @return Zend_Filter_Boolean
+     */
+    public function setType($type = null)
+    {
+        if (is_array($type)) {
+            $detected = 0;
+            foreach($type as $value) {
+                if (is_int($value)) {
+                    $detected += $value;
+                } elseif (in_array($value, $this->_constants)) {
+                    $detected += array_search($value, $this->_constants);
+                }
+            }
+
+            $type = $detected;
+        } elseif (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/Filter/Exception.php';
+            throw new Zend_Filter_Exception('Unknown type');
+        }
+
+        $this->_type = $type;
+        return $this;
+    }
+
+    /**
+     * Returns the set locale
+     *
+     * @return array
+     */
+    public function getLocale()
+    {
+        return $this->_locale;
+    }
+
+    /**
+     * Set the locales which are accepted
+     *
+     * @param  string|array|Zend_Locale $locale
+     * @throws Zend_Filter_Exception
+     * @return Zend_Filter_Boolean
+     */
+    public function setLocale($locale = null)
+    {
+        if (is_string($locale)) {
+            $locale = array($locale);
+        } elseif ($locale instanceof Zend_Locale) {
+            $locale = array($locale->toString());
+        } elseif (!is_array($locale)) {
+            require_once 'Zend/Filter/Exception.php';
+            throw new Zend_Filter_Exception('Locale has to be string, array or an instance of Zend_Locale');
+        }
+
+        require_once 'Zend/Locale.php';
+        foreach ($locale as $single) {
+            if (!Zend_Locale::isLocale($single)) {
+                require_once 'Zend/Filter/Exception.php';
+                throw new Zend_Filter_Exception("Unknown locale '$single'");
+            }
+        }
+
+        $this->_locale = $locale;
+        return $this;
+    }
+
+    /**
+     * Returns the casting option
+     *
+     * @return boolean
+     */
+    public function getCasting()
+    {
+        return $this->_casting;
+    }
+
+    /**
+     * Set the working mode
+     *
+     * @param  boolean $locale When true this filter works like cast
+     *                         When false it recognises only true and false
+     *                         and all other values are returned as is
+     * @throws Zend_Filter_Exception
+     * @return Zend_Filter_Boolean
+     */
+    public function setCasting($casting = true)
+    {
+        $this->_casting = (boolean) $casting;
+        return $this;
+    }
+
+    /**
+     * Defined by Zend_Filter_Interface
+     *
+     * Returns a boolean representation of $value
+     *
+     * @param  string $value
+     * @return string
+     */
+    public function filter($value)
+    {
+        $type    = $this->getType();
+        $casting = $this->getCasting();
+
+        // STRING YES (Localized)
+        if ($type >= self::YES) {
+            $type -= self::YES;
+            if (is_string($value)) {
+                require_once 'Zend/Locale.php';
+                $locales = $this->getLocale();
+                foreach ($locales as $locale) {
+                    if ($this->_getLocalizedQuestion($value, false, $locale) === false) {
+                        return false;
+                    }
+
+                    if (!$casting && ($this->_getLocalizedQuestion($value, true, $locale) === true)) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        // STRING FALSE (Localized)
+        if ($type >= self::FALSE_STRING) {
+            $type -= self::FALSE_STRING;
+            if (is_string($value) && (strtolower($value) == 'false')) {
+                return false;
+            }
+
+            if ((!$casting) && is_string($value) && (strtolower($value) == 'true')) {
+                return true;
+            }
+        }
+
+        // NULL (null)
+        if ($type >= self::NULL) {
+            $type -= self::NULL;
+            if (is_null($value)) {
+                return false;
+            }
+        }
+
+        // EMPTY_ARRAY (array())
+        if ($type >= self::EMPTY_ARRAY) {
+            $type -= self::EMPTY_ARRAY;
+            if (is_array($value) && ($value == array())) {
+                return false;
+            }
+        }
+
+        // ZERO ('0')
+        if ($type >= self::ZERO) {
+            $type -= self::ZERO;
+            if (is_string($value) && ($value == '0')) {
+                return false;
+            }
+
+            if ((!$casting) && (is_string($value)) && ($value == '1')) {
+                return true;
+            }
+        }
+
+        // STRING ('')
+        if ($type >= self::STRING) {
+            $type -= self::STRING;
+            if (is_string($value) && ($value == '')) {
+                return false;
+            }
+        }
+
+        // FLOAT (0.0)
+        if ($type >= self::FLOAT) {
+            $type -= self::FLOAT;
+            if (is_float($value) && ($value == 0.0)) {
+                return false;
+            }
+
+            if ((!$casting) && is_float($value) && ($value == 1.0)) {
+                return true;
+            }
+        }
+
+        // INTEGER (0)
+        if ($type >= self::INTEGER) {
+            $type -= self::INTEGER;
+            if (is_int($value) && ($value == 0)) {
+                return false;
+            }
+
+            if ((!$casting) && is_int($value) && ($value == 1)) {
+                return true;
+            }
+        }
+
+        // BOOLEAN (false)
+        if ($type >= self::BOOLEAN) {
+            $type -= self::BOOLEAN;
+            if (is_bool($value)) {
+                return $value;
+            }
+        }
+
+        if ($casting) {
+            return true;
+        }
+
+        return $value;
+    }
+
+    /**
+     * Determine the value of a localized string, and compare it to a given value
+     * 
+     * @param  string $value 
+     * @param  boolean $yes 
+     * @param  array $locale 
+     * @return boolean
+     */
+    protected function _getLocalizedQuestion($value, $yes, $locale)
+    {
+        if ($yes == true) {
+            $question = 'yes';
+            $return   = true;
+        } else {
+            $question = 'no';
+            $return   = false;
+        }
+        $str = Zend_Locale::getTranslation($question, 'question', $locale);
+        $str = explode(':', $str);
+        if (!empty($str)) {
+            foreach($str as $no) {
+                if (($no == $value) || (strtolower($no) == strtolower($value))) {
+                    return $return;
+                }
+            }
+        }
+    }
+}

tests/Zend/Filter/AllTests.php

@@ -29,6 +29,7 @@ if (!defined('PHPUnit_MAIN_METHOD')) {
 require_once 'Zend/Filter/AlnumTest.php';
 require_once 'Zend/Filter/AlphaTest.php';
 require_once 'Zend/Filter/BaseNameTest.php';
+require_once 'Zend/Filter/BooleanTest.php';
 require_once 'Zend/Filter/CallbackTest.php';
 require_once 'Zend/Filter/CompressTest.php';
 require_once 'Zend/Filter/DecompressTest.php';
@@ -117,6 +118,7 @@ class Zend_Filter_AllTests
         $suite->addTestSuite('Zend_Filter_AlnumTest');
         $suite->addTestSuite('Zend_Filter_AlphaTest');
         $suite->addTestSuite('Zend_Filter_BaseNameTest');
+        $suite->addTestSuite('Zend_Filter_BooleanTest');
         $suite->addTestSuite('Zend_Filter_CallbackTest');
         $suite->addTestSuite('Zend_Filter_CompressTest');
         $suite->addTestSuite('Zend_Filter_DecompressTest');

tests/Zend/Filter/BooleanTest.php

@@ -0,0 +1,802 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Filter
+ * @subpackage UnitTests
+ * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id$
+ */
+
+/**
+ * Test helper
+ */
+require_once dirname(__FILE__) . '/../../TestHelper.php';
+
+/**
+ * @see Zend_Filter_Boolean
+ */
+require_once 'Zend/Filter/Boolean.php';
+
+/**
+ * @category   Zend
+ * @package    Zend_Filter
+ * @subpackage UnitTests
+ * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @group      Zend_Filter
+ */
+class Zend_Filter_BooleanTest extends PHPUnit_Framework_TestCase
+{
+    /**
+     * Zend_Filter_Boolean object
+     *
+     * @var Zend_Filter_Boolean
+     */
+    protected $_filter;
+
+    /**
+     * Creates a new Zend_Filter_Boolean object for each test method
+     *
+     * @return void
+     */
+    public function setUp()
+    {
+        $this->_filter = new Zend_Filter_Boolean();
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testBasic()
+    {
+        $this->assertFalse($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertFalse($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertFalse($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertFalse($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertFalse($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertFalse($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertFalse($this->_filter->filter(null));
+        $this->assertTrue($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyBoolean()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::BOOLEAN);
+        $this->assertFalse($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertTrue($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertTrue($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertTrue($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertTrue($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertTrue($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertTrue($this->_filter->filter(null));
+        $this->assertTrue($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyInteger()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::INTEGER);
+        $this->assertTrue($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertFalse($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertTrue($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertTrue($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertTrue($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertTrue($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertTrue($this->_filter->filter(null));
+        $this->assertTrue($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyFloat()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::FLOAT);
+        $this->assertTrue($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertTrue($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertFalse($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertTrue($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertTrue($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertTrue($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertTrue($this->_filter->filter(null));
+        $this->assertTrue($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyString()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::STRING);
+        $this->assertTrue($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertTrue($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertTrue($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertFalse($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertTrue($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertTrue($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertTrue($this->_filter->filter(null));
+        $this->assertTrue($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyZero()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::ZERO);
+        $this->assertTrue($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertTrue($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertTrue($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertTrue($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertFalse($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertTrue($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertTrue($this->_filter->filter(null));
+        $this->assertTrue($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyArray()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::EMPTY_ARRAY);
+        $this->assertTrue($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertTrue($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertTrue($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertTrue($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertTrue($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertFalse($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertTrue($this->_filter->filter(null));
+        $this->assertTrue($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyNull()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::NULL);
+        $this->assertTrue($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertTrue($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertTrue($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertTrue($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertTrue($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertTrue($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertFalse($this->_filter->filter(null));
+        $this->assertTrue($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyPHP()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::PHP);
+        $this->assertFalse($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertFalse($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertFalse($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertFalse($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertFalse($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertFalse($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertFalse($this->_filter->filter(null));
+        $this->assertTrue($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyFalseString()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::FALSE_STRING);
+        $this->assertTrue($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertTrue($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertTrue($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertTrue($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertTrue($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertTrue($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertTrue($this->_filter->filter(null));
+        $this->assertFalse($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyYes()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::YES);
+        $this->_filter->setLocale('en');
+        $this->assertTrue($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertTrue($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertTrue($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertTrue($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertTrue($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertTrue($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertTrue($this->_filter->filter(null));
+        $this->assertTrue($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertFalse($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testOnlyAll()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::ALL);
+        $this->_filter->setLocale('en');
+        $this->assertFalse($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertFalse($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertFalse($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertFalse($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertFalse($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertFalse($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertFalse($this->_filter->filter(null));
+        $this->assertFalse($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertFalse($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testArrayConstantNotation()
+    {
+        $filter = new Zend_Filter_Boolean(
+            array(
+                'type' => array(
+                    Zend_Filter_Boolean::ZERO,
+                    Zend_Filter_Boolean::STRING,
+                    Zend_Filter_Boolean::BOOLEAN
+                )
+            )
+        );
+
+        $this->assertFalse($filter->filter(false));
+        $this->assertTrue($filter->filter(true));
+        $this->assertTrue($filter->filter(0));
+        $this->assertTrue($filter->filter(1));
+        $this->assertTrue($filter->filter(0.0));
+        $this->assertTrue($filter->filter(1.0));
+        $this->assertFalse($filter->filter(''));
+        $this->assertTrue($filter->filter('abc'));
+        $this->assertFalse($filter->filter('0'));
+        $this->assertTrue($filter->filter('1'));
+        $this->assertTrue($filter->filter(array()));
+        $this->assertTrue($filter->filter(array('xxx')));
+        $this->assertTrue($filter->filter(null));
+        $this->assertTrue($filter->filter('false'));
+        $this->assertTrue($filter->filter('true'));
+        $this->assertTrue($filter->filter('no'));
+        $this->assertTrue($filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testArrayConfigNotation()
+    {
+        $filter = new Zend_Filter_Boolean(
+            array(
+                'type' => array(
+                    Zend_Filter_Boolean::ZERO,
+                    Zend_Filter_Boolean::STRING,
+                    Zend_Filter_Boolean::BOOLEAN),
+                'test' => false
+            )
+        );
+
+        $this->assertFalse($filter->filter(false));
+        $this->assertTrue($filter->filter(true));
+        $this->assertTrue($filter->filter(0));
+        $this->assertTrue($filter->filter(1));
+        $this->assertTrue($filter->filter(0.0));
+        $this->assertTrue($filter->filter(1.0));
+        $this->assertFalse($filter->filter(''));
+        $this->assertTrue($filter->filter('abc'));
+        $this->assertFalse($filter->filter('0'));
+        $this->assertTrue($filter->filter('1'));
+        $this->assertTrue($filter->filter(array()));
+        $this->assertTrue($filter->filter(array('xxx')));
+        $this->assertTrue($filter->filter(null));
+        $this->assertTrue($filter->filter('false'));
+        $this->assertTrue($filter->filter('true'));
+        $this->assertTrue($filter->filter('no'));
+        $this->assertTrue($filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testMultiConstantNotation()
+    {
+        $filter = new Zend_Filter_Boolean(
+            Zend_Filter_Boolean::ZERO + Zend_Filter_Boolean::STRING + Zend_Filter_Boolean::BOOLEAN
+        );
+
+        $this->assertFalse($filter->filter(false));
+        $this->assertTrue($filter->filter(true));
+        $this->assertTrue($filter->filter(0));
+        $this->assertTrue($filter->filter(1));
+        $this->assertTrue($filter->filter(0.0));
+        $this->assertTrue($filter->filter(1.0));
+        $this->assertFalse($filter->filter(''));
+        $this->assertTrue($filter->filter('abc'));
+        $this->assertFalse($filter->filter('0'));
+        $this->assertTrue($filter->filter('1'));
+        $this->assertTrue($filter->filter(array()));
+        $this->assertTrue($filter->filter(array('xxx')));
+        $this->assertTrue($filter->filter(null));
+        $this->assertTrue($filter->filter('false'));
+        $this->assertTrue($filter->filter('true'));
+        $this->assertTrue($filter->filter('no'));
+        $this->assertTrue($filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testStringNotation()
+    {
+        $filter = new Zend_Filter_Boolean(
+            array(
+                'type' => array('zero', 'string', 'boolean')
+            )
+        );
+
+        $this->assertFalse($filter->filter(false));
+        $this->assertTrue($filter->filter(true));
+        $this->assertTrue($filter->filter(0));
+        $this->assertTrue($filter->filter(1));
+        $this->assertTrue($filter->filter(0.0));
+        $this->assertTrue($filter->filter(1.0));
+        $this->assertFalse($filter->filter(''));
+        $this->assertTrue($filter->filter('abc'));
+        $this->assertFalse($filter->filter('0'));
+        $this->assertTrue($filter->filter('1'));
+        $this->assertTrue($filter->filter(array()));
+        $this->assertTrue($filter->filter(array('xxx')));
+        $this->assertTrue($filter->filter(null));
+        $this->assertTrue($filter->filter('false'));
+        $this->assertTrue($filter->filter('true'));
+        $this->assertTrue($filter->filter('no'));
+        $this->assertTrue($filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testSingleStringNotation()
+    {
+        $filter = new Zend_Filter_Boolean(
+            'boolean'
+        );
+
+        $this->assertFalse($filter->filter(false));
+        $this->assertTrue($filter->filter(true));
+        $this->assertTrue($filter->filter(0));
+        $this->assertTrue($filter->filter(1));
+        $this->assertTrue($filter->filter(0.0));
+        $this->assertTrue($filter->filter(1.0));
+        $this->assertTrue($filter->filter(''));
+        $this->assertTrue($filter->filter('abc'));
+        $this->assertTrue($filter->filter('0'));
+        $this->assertTrue($filter->filter('1'));
+        $this->assertTrue($filter->filter(array()));
+        $this->assertTrue($filter->filter(array('xxx')));
+        $this->assertTrue($filter->filter(null));
+        $this->assertTrue($filter->filter('false'));
+        $this->assertTrue($filter->filter('true'));
+        $this->assertTrue($filter->filter('no'));
+        $this->assertTrue($filter->filter('yes'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testSettingLocale()
+    {
+        $this->_filter->setType(Zend_Filter_Boolean::ALL);
+        $this->_filter->setLocale('de');
+        $this->assertFalse($this->_filter->filter(false));
+        $this->assertTrue($this->_filter->filter(true));
+        $this->assertFalse($this->_filter->filter(0));
+        $this->assertTrue($this->_filter->filter(1));
+        $this->assertFalse($this->_filter->filter(0.0));
+        $this->assertTrue($this->_filter->filter(1.0));
+        $this->assertFalse($this->_filter->filter(''));
+        $this->assertTrue($this->_filter->filter('abc'));
+        $this->assertFalse($this->_filter->filter('0'));
+        $this->assertTrue($this->_filter->filter('1'));
+        $this->assertFalse($this->_filter->filter(array()));
+        $this->assertTrue($this->_filter->filter(array('xxx')));
+        $this->assertFalse($this->_filter->filter(null));
+        $this->assertFalse($this->_filter->filter('false'));
+        $this->assertTrue($this->_filter->filter('true'));
+        $this->assertTrue($this->_filter->filter('no'));
+        $this->assertTrue($this->_filter->filter('yes'));
+        $this->assertFalse($this->_filter->filter('nein'));
+        $this->assertTrue($this->_filter->filter('ja'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testSettingLocalePerConstructorString()
+    {
+        $filter = new Zend_Filter_Boolean(
+            'all', true, 'de'
+        );
+
+        $this->assertFalse($filter->filter(false));
+        $this->assertTrue($filter->filter(true));
+        $this->assertFalse($filter->filter(0));
+        $this->assertTrue($filter->filter(1));
+        $this->assertFalse($filter->filter(0.0));
+        $this->assertTrue($filter->filter(1.0));
+        $this->assertFalse($filter->filter(''));
+        $this->assertTrue($filter->filter('abc'));
+        $this->assertFalse($filter->filter('0'));
+        $this->assertTrue($filter->filter('1'));
+        $this->assertFalse($filter->filter(array()));
+        $this->assertTrue($filter->filter(array('xxx')));
+        $this->assertFalse($filter->filter(null));
+        $this->assertFalse($filter->filter('false'));
+        $this->assertTrue($filter->filter('true'));
+        $this->assertTrue($filter->filter('no'));
+        $this->assertTrue($filter->filter('yes'));
+        $this->assertFalse($filter->filter('nein'));
+        $this->assertTrue($filter->filter('ja'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testConfigObject()
+    {
+        require_once 'Zend/Config.php';
+        $options = array('type' => 'all', 'locale' => 'de');
+        $config  = new Zend_Config($options);
+
+        $filter = new Zend_Filter_Boolean(
+            $config
+        );
+
+        $this->assertFalse($filter->filter(false));
+        $this->assertTrue($filter->filter(true));
+        $this->assertFalse($filter->filter(0));
+        $this->assertTrue($filter->filter(1));
+        $this->assertFalse($filter->filter(0.0));
+        $this->assertTrue($filter->filter(1.0));
+        $this->assertFalse($filter->filter(''));
+        $this->assertTrue($filter->filter('abc'));
+        $this->assertFalse($filter->filter('0'));
+        $this->assertTrue($filter->filter('1'));
+        $this->assertFalse($filter->filter(array()));
+        $this->assertTrue($filter->filter(array('xxx')));
+        $this->assertFalse($filter->filter(null));
+        $this->assertFalse($filter->filter('false'));
+        $this->assertTrue($filter->filter('true'));
+        $this->assertTrue($filter->filter('no'));
+        $this->assertTrue($filter->filter('yes'));
+        $this->assertFalse($filter->filter('nein'));
+        $this->assertTrue($filter->filter('ja'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testSettingLocalePerConstructorArray()
+    {
+        $filter = new Zend_Filter_Boolean(
+            array('type' => 'all', 'locale' => 'de')
+        );
+
+        $this->assertFalse($filter->filter(false));
+        $this->assertTrue($filter->filter(true));
+        $this->assertFalse($filter->filter(0));
+        $this->assertTrue($filter->filter(1));
+        $this->assertFalse($filter->filter(0.0));
+        $this->assertTrue($filter->filter(1.0));
+        $this->assertFalse($filter->filter(''));
+        $this->assertTrue($filter->filter('abc'));
+        $this->assertFalse($filter->filter('0'));
+        $this->assertTrue($filter->filter('1'));
+        $this->assertFalse($filter->filter(array()));
+        $this->assertTrue($filter->filter(array('xxx')));
+        $this->assertFalse($filter->filter(null));
+        $this->assertFalse($filter->filter('false'));
+        $this->assertTrue($filter->filter('true'));
+        $this->assertTrue($filter->filter('no'));
+        $this->assertTrue($filter->filter('yes'));
+        $this->assertFalse($filter->filter('nein'));
+        $this->assertTrue($filter->filter('ja'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testSettingLocaleInstance()
+    {
+        $locale = new Zend_Locale('de');
+        $filter = new Zend_Filter_Boolean(
+            array('type' => 'all', 'locale' => $locale)
+        );
+
+        $this->assertFalse($filter->filter(false));
+        $this->assertTrue($filter->filter(true));
+        $this->assertFalse($filter->filter(0));
+        $this->assertTrue($filter->filter(1));
+        $this->assertFalse($filter->filter(0.0));
+        $this->assertTrue($filter->filter(1.0));
+        $this->assertFalse($filter->filter(''));
+        $this->assertTrue($filter->filter('abc'));
+        $this->assertFalse($filter->filter('0'));
+        $this->assertTrue($filter->filter('1'));
+        $this->assertFalse($filter->filter(array()));
+        $this->assertTrue($filter->filter(array('xxx')));
+        $this->assertFalse($filter->filter(null));
+        $this->assertFalse($filter->filter('false'));
+        $this->assertTrue($filter->filter('true'));
+        $this->assertTrue($filter->filter('no'));
+        $this->assertTrue($filter->filter('yes'));
+        $this->assertFalse($filter->filter('nein'));
+        $this->assertTrue($filter->filter('ja'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testWithoutCasting()
+    {
+        $locale = new Zend_Locale('de');
+        $filter = new Zend_Filter_Boolean(
+            array('type' => 'all', 'casting' => false, 'locale' => $locale)
+        );
+
+        $this->assertFalse($filter->filter(false));
+        $this->assertTrue($filter->filter(true));
+        $this->assertFalse($filter->filter(0));
+        $this->assertTrue($filter->filter(1));
+        $this->assertEquals(2, $filter->filter(2));
+        $this->assertFalse($filter->filter(0.0));
+        $this->assertTrue($filter->filter(1.0));
+        $this->assertEquals(0.5, $filter->filter(0.5));
+        $this->assertFalse($filter->filter(''));
+        $this->assertEquals('abc', $filter->filter('abc'));
+        $this->assertFalse($filter->filter('0'));
+        $this->assertTrue($filter->filter('1'));
+        $this->assertEquals('2', $filter->filter('2'));
+        $this->assertFalse($filter->filter(array()));
+        $this->assertEquals(array('xxx'), $filter->filter(array('xxx')));
+        $this->assertEquals(null, $filter->filter(null));
+        $this->assertFalse($filter->filter('false'));
+        $this->assertTrue($filter->filter('true'));
+        $this->assertEquals('no', $filter->filter('no'));
+        $this->assertEquals('yes', $filter->filter('yes'));
+        $this->assertFalse($filter->filter('nein'));
+        $this->assertTrue($filter->filter('ja'));
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testSettingFalseType()
+    {
+        try {
+            $this->_filter->setType(true);
+            $this->fail();
+        } catch (Zend_Exception $e) {
+            $this->assertContains('Unknown', $e->getMessage());
+        }
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testGetType()
+    {
+        $this->assertEquals(127, $this->_filter->getType());
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testSettingFalseLocaleType()
+    {
+        try {
+            $this->_filter->setLocale(true);
+            $this->fail();
+        } catch (Zend_Exception $e) {
+            $this->assertContains('Locale has to be', $e->getMessage());
+        }
+    }
+
+    /**
+     * Ensures that the filter follows expected behavior
+     *
+     * @return void
+     */
+    public function testSettingUnknownLocale()
+    {
+        try {
+            $this->_filter->setLocale('yy');
+            $this->fail();
+        } catch (Zend_Exception $e) {
+            $this->assertContains('Unknown locale', $e->getMessage());
+        }
+    }
+}