PHP SimpleDumper类代码示例

 function assert_attr_read_only($obj, $attr_name, $test_value, $msg = null)
 {
     if (is_null($msg)) {
         $msg = 'Exepected %s not to change but [got: %s] after setting [to: %s] [from: %s]';
     }
     $old_value = @$obj->{$attr_name};
     $this->expectError();
     $obj->{$attr_name} = $test_value;
     $new_value = @$obj->{$attr_name};
     $dumper = new SimpleDumper();
     $msg = sprintf($msg, get_class($obj) . '::$' . $attr_name, $dumper->describeValue($new_value), $dumper->describeValue($test_value), $dumper->describeValue($old_value));
     $this->assertEqual($old_value, $new_value, $msg);
 }

 /**
  *    Uses a stack trace to find the line of an assertion.
  *    @param array $stack      Stack frames top most first. Only
  *                             needed if not using the PHP
  *                             backtrace function.
  *    @return string           Location of first expect*
  *                             method embedded in format string.
  *    @access public
  *    @static
  */
 function getExpectationLine($stack = false)
 {
     if ($stack === false) {
         $stack = SimpleTestCompatibility::getStackTrace();
     }
     return SimpleDumper::getFormattedAssertionLine($stack);
 }

 public function testDescribeObject()
 {
     $dumper = new SimpleDumper();
     $this->assertPattern('/object/i', $dumper->describeValue(new DumperDummy()));
     $this->assertPattern('/DumperDummy/i', $dumper->describeValue(new DumperDummy()));
 }

 function dump($variable, $message = false)
 {
     $formatted = SimpleDumper::dump($variable);
     if ($message) {
         $formatted = $message . "\n" . $formatted;
     }
     $this->_runner->paintFormattedMessage($formatted);
     return $variable;
 }

 /**
  *    Renders the argument list as a string for
  *    messages.
  *    @param array $args    Incoming arguments.
  *    @return string        Simple description of type and value.
  */
 protected function renderArguments($args)
 {
     $descriptions = array();
     if (is_array($args)) {
         foreach ($args as $arg) {
             $dumper = new SimpleDumper();
             $descriptions[] = $dumper->describeValue($arg);
         }
     }
     return implode(', ', $descriptions);
 }

 /**
  *    Extracts the last assertion that was not within
  *    Simpletest itself. The name must start with "assert".
  *    @param array $stack      List of stack frames.
  *    @access public
  *    @static
  */
 function getFormattedAssertionLine($stack)
 {
     foreach ($stack as $frame) {
         if (isset($frame['file'])) {
             if (strpos($frame['file'], SIMPLE_TEST) !== false) {
                 if (dirname($frame['file']) . '/' == SIMPLE_TEST) {
                     continue;
                 }
             }
         }
         if (SimpleDumper::_stackFrameIsAnAssertion($frame)) {
             return ' at [' . $frame['file'] . ' line ' . $frame['line'] . ']';
         }
     }
     return '';
 }

 /**
  *    Will trigger a pass if both parameters refer
  *    to different variables. Fail otherwise. The objects
  *    have to be identical references though.
  *    This will fail under E_STRICT with objects. Use
  *    assertClone() for this.
  *    @param mixed $first           Object reference to check.
  *    @param mixed $second          Hopefully not the same object.
  *    @param string $message        Message to display.
  *    @return boolean               True on pass
  *    @access public
  */
 function assertCopy(&$first, &$second, $message = "%s")
 {
     $dumper = new SimpleDumper();
     $message = sprintf($message, "[" . $dumper->describeValue($first) . "] and [" . $dumper->describeValue($second) . "] should not be the same object");
     return $this->assertFalse(SimpleTestCompatibility::isReference($first, $second), $message);
 }

 /**
  * Inverted identity test.
  *
  * @param $first          First object handle.
  * @param $second         Hopefully a different handle.
  * @param $message        Message to display.
  */
 public function assertNotSame($first, $second, $message = '%s')
 {
     $dumper = new SimpleDumper();
     $message = sprintf($message, '[' . $dumper->describeValue($first) . '] and [' . $dumper->describeValue($second) . '] should not be the same object');
     return $this->assert(new falseExpectation(), SimpleTestCompatibility::isReference($first, $second), $message);
 }

 function contain($subject, $target, $message = '%s')
 {
     $dumper = new SimpleDumper();
     $message = "[ {$dumper->describeValue($subject)}] should contain [{$dumper->describeValue($target)}]";
     if (is_array($subject) && is_array($target)) {
         return $this->be_true(array_intersect($target, $subject) == $target, $message);
     } elseif (is_array($subject)) {
         return $this->be_true(in_array($target, $subject), $message);
     } elseif (is_string($subject)) {
         return $this->be_true(strpos($target, $subject) !== false, $message);
     }
 }

 /**
  * Will be true if the value is not empty.
  *
  * @param  mixed  $value   Supposedly not empty value.
  * @param  string $message Message to display.
  *
  * @return boolean True on pass.
  *
  * @access public
  */
 public function assertNotEmpty($value, $message = '%s')
 {
     $dumper = new SimpleDumper();
     $message = sprintf($message, '[' . $dumper->describeValue($value) . '] should not be empty');
     return $this->assertFalse(empty($value), $message);
 }

 public static function dump($data)
 {
     echo '<pre style="white-space: pre;padding:10px;font-family:Consolas,Menlo,Monaco,Lucida Console,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New,monospace,serif;margin-bottom:10px;background-color:#eee">';
     SimpleDumper::dump($data);
     echo '</pre>';
 }

 function assertNotNull($value, $message = '%s')
 {
     $dumper = new SimpleDumper();
     $message = sprintf($message, '[' . $dumper->describeValue($value) . '] should not be null');
     return $this->assertTrue(isset($value), $message);
 }

 /**
  *    Will be true if the value is not empty.
  *    @param mixed $value           Supposedly set value.
  *    @param string $message        Message to display.
  *    @return boolean               True on pass.
  *    @access public
  */
 function assertNotEmpty($value, $message = "%s")
 {
     $dumper = new SimpleDumper();
     $message = sprintf($message, "[" . $dumper->describeValue($value) . "] should not be null");
     return $this->assertTrue(!empty($value), $message);
 }

 /**
  *    Creates a human readable description of the
  *    difference between two variables. Uses a
  *    dynamic call.
  *    @param mixed $first        First variable.
  *    @param mixed $second       Value to compare with.
  *    @param boolean $identical  If true then type anomolies count.
  *    @return string             Description of difference.
  *    @access public
  */
 function describeDifference($first, $second, $identical = false)
 {
     $difference = parent::describeDifference($first, $second, $identical);
     $difference = htmlentities($difference, ENT_COMPAT, 'UTF-8');
     if ($this->getType($first) == 'String') {
         $diff = $this->describeStringDifferenceAsADiff($first, $second, $identical);
         if ($diff) {
             $difference .= PHP_EOL . PHP_EOL;
             $difference .= '<fieldset><legend>Unified diff</legend>';
             $difference .= '<div class="diff">' . $diff . '</div>';
             $difference .= '</fieldset>';
         }
     }
     return $difference;
 }