assert_options
Note that func_get_args() should be used carefully and never in a string! For example:
<?php
function asserted_normal($a, $b) {
assert(var_dump(func_get_args()));
}
function asserted_string($a, $b) {
assert('var_dump(func_get_args())');
}
?>
<?php asserted_normal(1,2) ?> prints
array(2) {
[0]=>
int(1)
[1]=>
int(2)
}
but <?php asserted_string(3,4) ?> prints
array(1) {
[0]=>
string(25) "var_dump(func_get_args())"
}
This is because of that the string passed to assert() is being evaled inside assert, and not your function. Also, note that this works correctly, because of the eval scope:
<?php
function asserted_evaled_string($a, $b) {
assert(eval('var_dump(func_get_args())'));
}
asserted_evaled_string(5,6);
?>
array(2) {
[0]=>
int(5)
[1]=>
int(6)
}
(oh, and for simplicity's sake the evaled code doesn't return true, so don't worry that it fails assertion...)
assert
(PHP 4, PHP 5)
assert — Revisa si la aserción es evaluada a FALSE
Descripción
assert() revisará la asercion dada y tomará una acción apropiada si su resultado es FALSE.
Si la asercion es dada como una cadena, ésta será evaluada como código PHP por assert(). Las ventajas de una asercion tipo cadena son menor sobrecarga cuando el chequeo de aserciones se encuentre deshabilitado, y la producción de mensajes que contengan la expresión asercion cuando ésta falle. Esto quiere decir que si pasa una condición booleana como asercion , esta condición no aparecerá como parámetro de la función de aserción, la cual pudo haber definido con la función assert_options(), la condición es convertida en una cadena antes de llamar tal función gestora, y el valor booleano FALSE es convertido como una cadena vacía.
Las aserciones deben ser usadas como una característica de depuración únicamente. Puede usarlas para realizar chequeos de integridad que prueben condiciones que deberían ser siempre TRUE y que indiquen algunos errores de programación si no se cumplen, o que chequeen por la presencia de ciertas características como las funciones de extensión, o ciertos límites y características de sistema.
Las aserciones no deberían ser usadas para operaciones normales de tiempo de ejecución como chequeos de parámetros de entrada. Como regla de oro, su código debería trabajar correctamente siempre si el chequeo de aserciones no está activado.
El comportamiento de assert() puede ser configurado por assert_options() o mediante los parámetros .ini descritos en su respectiva página del manual.
La función assert_options() o la directiva de configuración ASSERT_CALLBACK permiten el uso de llamadas de retorno para gestionar las aserciones fallidas.
Las llamadas de retorno de assert() son particularmente útiles para productos que prueben procesos automatizados de generación, ya que le permitin capturar fácilmente el código pasado a la aserción, junto con información sobre dónde se creó la aserción. Aunque esta información puede ser capturada mediante otros métodos, ¡el uso de aserciones lo hace mucho más rápido y sencillo!
La llamada de retorno debe aceptar tres argumentos. El primer argumento contendrá el archivo en el que ha fallado la aserción. El segundo argumento contendrá la línea en la que falló la aserción, y el tercer argumento contendrá la expresión que falló (si está disponible - valores literales como 1 o "dos" no serán pasados a través de este argumento).
Lista de parámetros
- asercion
-
La aserción.
Valores retornados
FALSE si la aserción es falsa, TRUE de lo contrario.
Ejemplos
Example #1 Gestionar una aserción fallida con una función personalizada
<?php
// Activar las aserciones y hacerlas silenciosas
assert_options(ASSERT_ACTIVE, 1);
assert_options(ASSERT_WARNING, 0);
assert_options(ASSERT_QUIET_EVAL, 1);
// Crear una función gestora
function mi_gestor_de_asercion($archivo, $linea, $codigo)
{
echo "<hr>Aserción Fallida:
Archivo '$archivo'<br />
Línea '$linea'<br />
Código '$codigo'<br /><hr />";
}
// Configurar la llamada de retorno
assert_options(ASSERT_CALLBACK, 'mi_gestor_de_asercion');
// Crear una aserción que debería fallar
assert('mysql_query ("")');
?>
add a note
User Contributed Notesassert
Krzysztof 'ChanibaL' Bociurko
01-Oct-2007 06:13
01-Oct-2007 06:13
mail<at>aaron-mueller.de
13-Sep-2006 10:51
13-Sep-2006 10:51
Here is a simple demonstration of Design By Contract with PHP
<?php
assert_options(ASSERT_ACTIVE, 1);
assert_options(ASSERT_WARNING, 0);
assert_options(ASSERT_BAIL, 1);
assert_options(ASSERT_CALLBACK, 'dcb_callback');
function dcb_callback($script, $line, $message) {
echo "<h1>Condition failed!</h1><br />
Script: <strong>$script</strong><br />
Line: <strong>$line</strong><br />
Condition: <br /><pre>$message</pre>";
}
// Parameters
$a = 5;
$b = 'Simple DCB with PHP';
// Pre-Condition
assert('
is_integer($a) &&
($a > 0) &&
($a < 20) &&
is_string($b) &&
(strlen($b) > 5);
');
// Function
function combine($a, $b) {
return "Kombined: " . $b . $a;
}
$result = combine($a, $b);
// Post-Condition
assert('
is_string($result) &&
(strlen($result) > 0);
');
// All right, the Function works fine
var_dump($result);
?>
gk at proliberty dot com
26-Aug-2005 07:35
26-Aug-2005 07:35
If you expect your code to be able to work well with other code, then you should not make any assumptions about the current state of assert_options() flags, prior to calling assert(): other code may disable ASSERT_ACTIVE, without you knowing it - this would render assert() useless!
To avoid this, ALWAYS set assert_options() IMMEDIATELY before calling assert(), per the C++ paradigm for assertion usage:
In one C++ source file, you can define and undefine NDEBUG multiple times, each time followed by #include <cassert>, to enable or disable the assert macro multiple times in the same source file.
Here is how I workaround this issue in my PHP code:
<?php
//////////////////////////////////////////////////////////////////////
/// phpxAssertHandler_f
//////////////////////////////////////////////////////////////////////
/**
* @desc Handler which also sets up assert options if not being called as handler
Always fatal when assertion fails
Always make sure assertion is enabled
Cannot depend on other code not using assert or using its own assert handler!
USAGE:
// customize error level of assertion (php assert_options() only allows E_WARNING or nothing at all):
phpxAssertHandler_f(E_USER_NOTICE);
// control assertion active state: not dependent on anything another piece of code might do with ASSERT_ACTIVE
$GLOBALS['MY_ASSERT_ACTIVE']=false;
phpxAssertHandler_f(E_USER_NOTICE,$GLOBALS['MY_ASSERT_ACTIVE']);
// use alternate assertion callback function:
// NOTE: pass null as custom options parameter to use default options
// NOTE: pass no values for assert options parameter array elements to use default options
$GLOBALS['MY_ASSERT_ACTIVE']=false;
$GLOBALS['MY_ASSERT_CALLBACK']='myAssertCallback';
phpxAssertHandler_f(
null,
array(
0=>$GLOBALS['MY_ASSERT_ACTIVE'],
3=>$GLOBALS['MY_ASSERT_CALLBACK'],
)
);
* @param mixed = file or options
* @param line
* @param code
* @return void
*/
function phpxAssertHandler_f($file_or_custom_options=null, $line_or_assert_options=null, $code=null){
static $custom_options;
$debug = false;
if (is_null($code)){
// set default assert_options
$assert_options[]=1;//ASSERT_ACTIVE
$assert_options[]=0;//ASSERT_WARNING -
$assert_options[]=0;//ASSERT_QUIET_EVAL
$assert_options[]=__FUNCTION__;//ASSERT_CALLBACK
// set default custom_options
$custom_options[]=E_USER_ERROR;// error level
if (!is_null($line_or_assert_options)){
// assert_options are passed in
if (!is_array($line_or_assert_options)){
$line_or_assert_options=array($line_or_assert_options);
}
foreach ($line_or_assert_options as $i=>$assert_option){
if ($assert_option===true) $assert_option=1;
if ($assert_option===false) $assert_option=0;
$assert_options[$i]=$assert_option;
if($debug) echo ("assert_options[$i]=$assert_option\n");
}
}
if (!is_null($file_or_custom_options)){
// custom_options are passed in
if (!is_array($file_or_custom_options)){
$file_or_custom_options=array($file_or_custom_options);
}
foreach ($file_or_custom_options as $i=>$custom_option){
if ($custom_option===true) $custom_option=1;
if ($custom_option===false) $custom_option=0;
$custom_options[$i]=$custom_option;
if($debug) echo ("custom_options[$i]=$custom_option\n");
}
}
// set assert options
@assert_options (ASSERT_ACTIVE, $assert_options[0]);
@assert_options (ASSERT_WARNING, $assert_options[1]);
@assert_options (ASSERT_QUIET_EVAL, $assert_options[2]);
@assert_options (ASSERT_CALLBACK, $assert_options[3]);
} else {
// we are acting as a callback function
$file = $file_or_custom_options;
$line = $line_or_assert_options;
$msg="ASSERTION FAILED: $code";
phpxErrorHandler_f ($custom_options[0],$msg,$file,$line);
}
}//phpxAssertHandler_f()
?>
nyk at forumone dot com
26-Aug-2002 06:56
26-Aug-2002 06:56
Assertion is a useful debugging feature, but for building unit tests and automated regression tests you should seriously consider using the PHPtest in the PEAR archive (http://pear.php.net/package-info.php?pacid=38) that is based on the JUnit framework for Java. There is also another unit testing framework, also based on JUnit and also called PHPunit on SourceForge (http://sourceforge.net/projects/phpunit/). I believe it is an independent effort from that on PEAR.