!C99Shell v. 1.0 pre-release build #13!

Software: Apache. PHP/5.5.15 

uname -a: Windows NT SVR-DMZ 6.1 build 7600 (Windows Server 2008 R2 Enterprise Edition) i586 

SYSTEM 

Safe-mode: OFF (not secure)

C:\dmz\php\pear\PHPUnit\   drwxrwxrwx
Free 4.08 GB of 39.52 GB (10.32%)
Detected drives: [ a ] [ c ] [ d ] [ e ] [ f ]
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


Viewing file:     Skeleton.php (14.13 KB)      -rw-rw-rw-
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**
 * PHP Version 4
 *
 * Copyright (c) 2002-2005, Sebastian Bergmann <sb@sebastian-bergmann.de>.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *
 *   * Neither the name of Sebastian Bergmann nor the names of his
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRIC
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * @category   Testing
 * @package    PHPUnit
 * @author     Scott Mattocks <scott@crisscott.com>
 * @copyright  2002-2005 Sebastian Bergmann <sb@sebastian-bergmann.de>
 * @license    http://www.opensource.org/licenses/bsd-license.php  BSD License
 * @version    CVS: $Id: Skeleton.php,v 1.8 2005/11/10 09:47:14 sebastian Exp $
 * @link       http://pear.php.net/package/PHPUnit
 * @since      File available since Release 1.1.0
 */

/**
 * Class for creating a PHPUnit_TestCase skeleton file.
 *
 * This class will take a classname as a parameter on construction and will
 * create a PHP file that contains the skeleton of a PHPUnit_TestCase
 * subclass. The test case will contain a test foreach method of the class.
 * Methods of the parent class will, by default, be excluded from the test
 * class. Passing and optional construction parameter will include them.
 *
 * Example
 *
 *   <?php
 *   require_once 'PHPUnit/Skeleton.php';
 *   $ps = new PHPUnit_Skeleton('PHPUnit_Skeleton', 'PHPUnit/Skeleton.php');
 *
 *   // Generate the test class.
 *   // Default settings will not include any parent class methods, but
 *   // will include private methods.
 *   $ps->createTestClass();
 *
 *   // Write the new test class to file.
 *   // By default, code to run the test will be included.
 *   $ps->writeTestClass();
 *   ?>
 *
 * Now open the skeleton class and fill in the details.
 * If you run the test as is, all tests will fail and
 * you will see plenty of undefined constant errors.
 *
 * @category   Testing
 * @package    PHPUnit
 * @author     Scott Mattocks <scott@crisscott.com>
 * @copyright  2002-2005 Sebastian Bergmann <sb@sebastian-bergmann.de>
 * @license    http://www.opensource.org/licenses/bsd-license.php  BSD License
 * @version    Release: 1.3.2
 * @link       http://pear.php.net/package/PHPUnit
 * @since      Class available since Release 1.1.0
 */
class PHPUnit_Skeleton {
    
/**
     * Path to the class file to create a skeleton for.
     * @var string
     */
    
var $classPath;

    
/**
     * The name of the class
     * @var string
     */
    
var $className;

    
/**
     * Path to the configuration file needed by class to test.
     * @var string
     */
    
var $configFile;

    
/**
     * Whether or not to include the methods of the parent class when testing.
     * @var boolean
     */
    
var $includeParents;

    
/**
     * Whether or not to test private methods.
     * @var boolean
     */
    
var $includePrivate;

    
/**
     * The test class that will be created.
     * @var string
     */
    
var $testClass;

    
/**
     * Constructor. Sets the class members and check that the class
     * to test is accessible.
     *
     * @access public
     * @param  string  $className
     * @param  string  $classPath
     * @param  boolean $includeParents Wheter to include the parent's methods in the test.
     * @return void
     */
    
function PHPUnit_Skeleton($className$classPath$includeParents FALSE$includePrivate TRUE) {
        
// Set up the members.
        
if (@is_readable($classPath)) {
            
$this->className $className;
            
$this->classPath $classPath;
        } else {
            
$this->_handleErrors($classPath ' is not readable. Cannot create test class.');
        }

        
// Do we want to include parent methods?
        
$this->includeParents $includeParents;

        
// Do we want to allow private methods?
        
$this->includePrivate $includePrivate;
    }

    
/**
     * The class to test may require a special config file before it can be
     * instantiated. This method lets you set that file.
     *
     * @access public
     * @param  string $configPath
     * @return void
     */
    
function setConfigFile($configFile) {
        
// Check that the file is readable
        
if (@is_readable($configFile)) {
            
$this->configFile $configFile;
        } else {
            
$this->_handleErrors($configFile ' is not readable. Cannot create test class.');
        }
    }

    
/**
     * Create the code that will be the skeleton of the test case.
     *
     * The test case must have a clss definition, one var, a constructor
     * setUp, tearDown, and methods. Optionally and by default the code
     * to run the test is added when the class is written to file.
     *
     * @access public
     * @param  none
     * @return void
     */
    
function createTestClass() {
        
// Instantiate the object.
        
if (isset($this->configFile)) {
            require_once 
$this->configFile;
        }

        require_once 
$this->classPath;

        
// Get the methods.
        
$classMethods get_class_methods($this->className);

        
// Remove the parent methods if needed.
        
if (!$this->includeParents) {
            
$parentMethods get_class_methods(get_parent_class($this->className));

            if (
count($parentMethods)) {
                
$classMethods array_diff($classMethods$parentMethods);
            }
        }

        
// Create the class definition, constructor, setUp and tearDown.
        
$this->_createDefinition();
        
$this->_createConstructor();
        
$this->_createSetUpTearDown();

        if (
count($classMethods)) {
            
// Foreach method create a test case.
            
foreach ($classMethods as $method) {
                
// Unless it is the constructor.
                
if (strcasecmp($this->className$method) !== 0) {
                  
// Check for private methods.
                  
if (!$this->includePrivate && strpos($method'_') === 0) {
                      continue;
                  } else {
                      
$this->_createMethod($method);
                  }
                }
            }
        }

        
// Finis off the class.
        
$this->_finishClass();
    }

    
/**
     * Create the class definition.
     *
     * The definition consist of a header comment, require statment
     * for getting the PHPUnit file, the actual class definition,
     * and the definition of the class member variable.
     *
     * All of the code needed for the new class is stored in the
     * testClass member.
     *
     * @access private
     * @param  none
     * @return void
     */
    
function _createDefinition() {
        
// Create header comment.
        
$this->testClass =
          
"/**\n" .
          
" * PHPUnit test case for " $this->className "\n" .
          
" * \n" .
          
" * The method skeletons below need to be filled in with \n" .
          
" * real data so that the tests will run correctly. Replace \n" .
          
" * all EXPECTED_VAL and PARAM strings with real data. \n" .
          
" * \n" .
          
" * Created with PHPUnit_Skeleton on " date('Y-m-d') . "\n" .
          
" */\n";

        
// Add the require statements.
        
$this->testClass .= "require_once 'PHPUnit.php';\n";

        
// Add the class definition and variable definition.
        
$this->testClass .=
          
"class " $this->className "Test extends PHPUnit_TestCase {\n\n" .
          
"    var \$" $this->className ";\n\n";
    }

    
/**
     * Create the class constructor. (PHP4 style)
     *
     * The constructor simply calls the PHPUnit_TestCase method.
     * This code is taken from the PHPUnit documentation.
     *
     * All of the code needed for the new class is stored in the
     * testClass member.
     *
     * @access private
     * @param  none
     * @return void
     */
    
function _createConstructor() {
        
// Create the test class constructor.
        
$this->testClass.=
          
"    function " $this->className "Test(\$name)\n" .
          
"    {\n" .
          
"        \$this->PHPUnit_TestCase(\$name);\n" .
          
"    }\n\n";
    }

    
/**
     * Create setUp and tearDown methods.
     *
     * The setUp method creates the instance of the object to test.
     * The tearDown method releases the instance.
     * This code is taken from the PHPUnit documentation.
     *
     * All of the code needed for the new class is stored in the
     * testClass member.
     *
     * @access private
     * @param  none
     * @return void
     */
    
function _createSetUpTearDown() {
        
// Create the setUp method.
        
$this->testClass .=
          
"    function setUp()\n" .
          
"    {\n";

        if (isset(
$this->configFile)) {
            
$this->testClass .=
            
"        require_once '" $this->configFile "';\n";
        }

        
$this->testClass .=
          
"        require_once '" $this->classPath "';\n" .
          
"        \$this->" $this->className " =& new " $this->className "(PARAM);\n" .
          
"    }\n\n";

        
// Create the tearDown method.
        
$this->testClass .=
          
"    function tearDown()\n" .
          
"    {\n" .
          
"        unset(\$this->" $this->className ");\n" .
          
"    }\n\n";
    }

    
/**
     * Create a basic skeleton for test methods.
     *
     * This code is taken from the PHPUnit documentation.
     *
     * All of the code needed for the new class is stored in the
     * testClass member.
     *
     * @access private
     * @param  none
     * @return void
     */
    
function _createMethod($methodName) {
        
// Create a test method.
        
$this->testClass .=
          
"    function test" $methodName "()\n" .
          
"    {\n" .
          
"        \$result   = \$this->" $this->className "->" $methodName "(PARAM);\n" .
          
"        \$expected = EXPECTED_VAL;\n" .
          
"        \$this->assertEquals(\$expected, \$result);\n" .
          
"    }\n\n";
    }

    
/**
     * Add the closing brace needed for a proper class definition.
     *
     * All of the code needed for the new class is stored in the
     * testClass member.
     *
     * @access private
     * @param  none
     * @return void
     */
    
function _finishClass() {
        
// Close off the class.
        
$this->testClass.= "}\n";
    }

    
/**
     * Create the code that will actually run the test.
     *
     * This code is added by default so that the test can be run
     * just by running the file. To have it not added pass false
     * as the second parameter to the writeTestClass method.
     * This code is taken from the PHPUnit documentation.
     *
     * All of the code needed for the new class is stored in the
     * testClass member.
     *
     * @access private
     * @param  none
     * @return void
     */
    
function _createTest() {
        
// Create a call to the test.
        
$test =
          
"// Running the test.\n" .
          
"\$suite  = new PHPUnit_TestSuite('" $this->className "Test');\n" .
          
"\$result = PHPUnit::run(\$suite);\n" .
          
"echo \$result->toString();\n";

        return 
$test;
    }

    
/**
     * Write the test class to file.
     *
     * This will write the test class created using the createTestClass
     * method to a file called <className>Test.php. By default the file
     * is written to the current directory and will have code to run
     * the test appended to the bottom of the file.
     *
     * @access public
     * @param  string  $destination The directory to write the file to.
     * @param  boolean $addTest     Wheter to add the test running code.
     * @return void
     */
    
function writeTestClass($destination './'$addTest TRUE) {
        
// Check for something to write to file.
        
if (!isset($this->testClass)) {
            
$this->_handleErrors('Noting to write.'PHPUS_WARNING);
            return;
        }

        
// Open the destination file.
        
$fp fopen($destination $this->className 'Test.php''w');
        
fwrite($fp"<?php\n");

        
// Write the test class.
        
fwrite($fp$this->testClass);

        
// Add the call to test the class in the file if we were asked to.
        
if ($addTest) {
            
fwrite($fp$this->_createTest());
        }

        
// Close the file.
        
fwrite($fp"?>\n");
        
fclose($fp);
    }

    
/**
     * Error handler.
     *
     * This method should be rewritten to use the prefered error
     * handling method. (PEAR_ErrorStack)
     *
     * @access private
     * @param  string  $message The error message.
     * @param  integer $type    An indication of the severity of the error.
     * @return void             Code may cause PHP to exit.
     */
    
function _handleErrors($message$type E_USER_ERROR) {
        
// For now just echo the message.
        
echo $message;

        
// Check to see if we should quit.
        
if ($type == E_USER_ERROR) {
            exit;
        }
    }
}

/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * c-hanging-comment-ender-p: nil
 * End:
 */
?>

:: Command execute ::

Enter:
 
Select:
 

:: Search ::
  - regexp 

:: Upload ::
 
[ ok ]

:: Make Dir ::
 
[ ok ]
:: Make File ::
 
[ ok ]

:: Go Dir ::
 
:: Go File ::
 

--[ c99shell v. 1.0 pre-release build #13 powered by Captain Crunch Security Team | http://ccteam.ru | Generation time: 0.0312 ]--