Descarga php testing - Descarga del código fuente php testing

Pruebas de PHP

Prueba

Biblioteca para pruebas PHPUnit.

Uso

Instalar por compositor

 > composer require --dev milanowicz/php-testing

Métodos

Ejemplo de uso de una clase abstracta en su ClassTest:

 class UnitTest extends Milanowicz  Testing TestCase
{
    public function testMethod (): void
    {
        // All Traits in abstract MilanowiczTestingTestCase are extends!
        // See below for further details from Trait methods
    }
}

O importar rasgos para usarlos:

 class UnitTest extends What  Ever TestCase
{
    use Milanowicz  Testing TestTrait;

    public function testMethod (): void
    {
        // Access to private or protected Method
        $ this -> accessMethod (( object ) Class, ( string ) Method);
        // Run test(s) in it and when an assertion failed would throw, see message and data for the reason
        $ this -> catchAssertionFailing (( array ) $ data , function ( $ data ) {
            $ this -> assertEquals ( ' whatEver ' , $ data [ ' whatEver ' ]);
        }, ( string ) $ catchData = ExpectationFailedException::class);
        // Create class without constructor
        $ this -> createInstanceWithoutConstructor (( string ) Class);
        // Call a private or protected Method with argument(s)
        $ this -> invokeMethod (( object ) Class, ( string ) Method, (mixed) ArgumentsForMethod);
        // Set a value to private or protected property 
        $ this -> setProperty (( object ) Class, ( string ) Property, (mixed) PropertyValue);
        // Get a value from a private or protected property back
        $ this -> getProperty (( object ) Class, ( string ) Property);
        // Execute test of number tries to check, if it runs multiply times successfully
        $ this -> testLoops ((callable) Function, ( int ) NumberOfTries, ( int ) NumberOfErrors);
        // Execute test and when it's throw an exception, then try it again
        $ this -> tryTest ((callable) Function, ( int ) NumberOfTries);
    }
}

TestPerformanceTrait consiste en ejecutar dos funciones y ver cuál de ellas fue más rápida:

 class UnitTest extends What  Ever TestCase
{
    use Milanowicz  Testing TestPerformanceTrait;

    public function testMethod (): void
    {
        // Example functions
        $ cb1 = static function () {
            usleep ( 100 );
        };
        $ cb2 = static function () {
            usleep ( 200 );
        };

        // Call both methods after each other and save run times from them
        $ this -> measureTime ((callable) $ cb1 , (callable) $ cb2 , ( int ) $ n = 20 );
        // Check AVG and Student-Test
        $ this -> checkPerformance (( bool ) $ function1 = true , ( float ) $ pValue = 0.05 );
        // $cb1 should be faster 
        $ this -> checkMeanTime (( bool ) $ function1 = true );
        // $cb2 should be slower and throw an Exception 
        $ this -> checkMeanTime (( bool ) false );
        // Check if $cb1 is significant faster
        $ this -> checkStudentTest (( float ) $ pValue = 0.05 );
        // Get all time measures
        $ this -> getTimeMeasures ();
        // Get both in array with AVG, STD and Median 
        $ this -> getTimeStats ();
        // Get result from Student-T test 
        $ this -> getTimeSignificance ();
        // Clear all times and measures
        $ this -> clearTimes (); 
    }
}

Excepción

Uso de AssertionFailedException para obtener datos en un mensaje de excepción:

 $ e = new AssertionFailedException (
    ( string ) $ message = ' Testing ' ,
    ( array ) $ data = [ 1 ],
    ( int ) $ code = 1 ,
    ( null |Throwable) $ previous = null ,
);
$ e -> toArray (); // => [1]
$ e -> count (); // => 1
$ e -> toString (); // => Message and Data as String

// and all Exception methods are available:
$ e -> getMessage (); // => Message and Data as String
$ e -> getCode (); // => 1
$ e -> getPrevious (); // => null OR a Throwable object