Assert that the value is boolean False.

@param mixed $value
@param string $message
@param string $propertyPath
@return void
@throws Exception
488720
static public function false($value, $message = null, $propertyPath = null)
        {
            if ($value !== false) {
                $message = $message ?: sprintf(
                    'Value "%s" is not FALSE.',
                    static::stringify($value)
                );

                throw static::createException($value, $message, static::INVALID_FALSE, $propertyPath);
            }
        }
595466
public static function isNullOrInteger($value, $message = null)
    {
        if (!is_null($value) && !is_int($value)) {
            throw new InvalidArgumentException(sprintf(
                $message ?: 'Expected null or integer, but got %s',
                Helper::typeToString($value)
            ));
        }
    }
1260027
static public function string($value, $message = null, $propertyPath = null)
        {
            if ( ! is_string($value)) {
                $message = $message ?: sprintf(
                    'Value "%s" expected to be string, type %s given.',
                    static::stringify($value),
                    gettype($value)
                );

                throw static::createException($value, $message, static::INVALID_STRING, $propertyPath);
            }
        }
1241372
static public function keyExists($value, $key, $message = null, $propertyPath = null)
        {
            static::isArray($value);

            if (!Arrays::exists($key, $value)) {
                $message = $message ?: sprintf(
                    'Array does not contain an element with key "%s"',
                    static::stringify($key)
                );

                throw static::createException($value, $message, static::INVALID_KEY_EXISTS, $propertyPath, array('key' => $key));
            }
        }
1295152
static public function isInstanceOf($value, $className, $message = null, $propertyPath = null)
        {
            if ( ! ($value instanceof $className)) {
                $message = $message ?: sprintf(
                    'Class "%s" was expected to be instanceof of "%s" but is not.',
                    static::stringify($value),
                    $className
                );

                throw static::createException($value, $message, static::INVALID_INSTANCE_OF, $propertyPath, array('class' => $className));
            }
        }
771098
public function isFalse($value, $message = '')
    {
        $this->assertion->setActual($value);

        return $this->assertion->to->be->false($message);
    }
103538
public static void assertFalse(String message, boolean value) {
        if (!value) {
            pass(message);
        } else {
            fail(message, null);
        }
    }
1177048
public static function isFile($value, $message = null)
    {
        if (!is_string($value) || !is_file($value)) {
            throw new InvalidArgumentException(sprintf(
                $message ?: 'Expected file, but got %s',
                Helper::valueToString($value)
            ));
        }
    }
605375
public static function isNullOrFile($value, $message = null)
    {
        if (!is_null($value) && !(is_string($value) && is_file($value))) {
            throw new InvalidArgumentException(sprintf(
                $message ?: 'Expected null or file, but got %s',
                Helper::valueToString($value)
            ));
        }
    }
76383
public static function isNullOrInstanceOf($value, $class, $message = null)
    {
        if (!is_null($value) && !$value instanceof $class) {
            throw new InvalidArgumentException(sprintf(
                $message ?: 'Expected null or instance of %2$s, but got %s',
                Helper::typeToString($value),
                $class
            ));
        }
    }
1356219
public function isNotNull($message = null, $subProperty = null)
    {
        $this->callback = function ($builder) use ($subProperty) {
            $builder = ($subProperty !== null && !empty($builder->{$subProperty}))
                        ? $builder->{$subProperty}
                        : $builder;
            if (!property_exists($builder, $this->target->property)
                && !isset($builder->{$this->target->property})
            ) {
                throw new BuilderException(
                    sprintf(
                        'Property `%s` does not exist on `%s`',
                        $this->target->property,
                        get_class($builder)
                    )
                );
            }
            $value = $builder->{$this->target->property};
            return null !== $value;
        };
        $this->message = !empty($message)
            ? $message
            // TODO: implement a way to expose property name
            : sprintf(
                '%s cannot be null for this transaction type.',
                $this->target->property
            );

        if ($this->precondition) {
            return $this->target;
        }

        return $this->parent->of($this->target->type, $this->target->modifier);
    }
459334
public static Boolean assertTrue(Boolean value, String message) {
        if (!Boolean.valueOf(value))
            throw new IllegalArgumentException(message);
        return value;
    }
153205
public static function assertBool($actual, string $message = '')
    {
        self::assertTypeOfScalar($actual, $message, 'assertBool', new ScalarConstraint(ScalarConstraint::TYPE_BOOL));
    }
557754
private function assertArrayValue($value, $message = null)
    {
        if (!is_array($value)) {
            return $this->failedAssert(sprintf('value is an array, got "%s".', is_object($value) ? get_class($value) : gettype($value)), $message);
        }

        return true;
    }
700419
static public function boolean($value, $message = null, $propertyPath = null)
        {
            if ( ! is_bool($value)) {
                $message = $message ?: sprintf(
                    'Value "%s" is not a boolean.',
                    static::stringify($value)
                );

                throw static::createException($value, $message, static::INVALID_BOOLEAN, $propertyPath);
            }
        }
144060
public function deepPropertyNotVal($object, $property, $value, $message = '')
    {
        $this->assertion->setActual($object);

        return $this->assertion->to->not->have->deep->property($property, $value, $message);
    }
665026
static public function alnum($value, $message = null, $propertyPath = null)
        {
            try {
                static::regex($value, '(^([a-zA-Z]{1}[a-zA-Z0-9]*)$)');
            } catch(AssertionFailedException $e) {
                $message = $message ?: sprintf(
                    'Value "%s" is not alphanumeric, starting with letters and containing only letters and numbers.',
                    static::stringify($value)
                );

                throw static::createException($value, $message, static::INVALID_ALNUM, $propertyPath);
            }
        }