tests/PHPUnit/PHP/CodeCoverage/Report/Node.php

   1 <?php
   2 /**
   3  * PHP_CodeCoverage
   4  *
   5  * Copyright (c) 2009-2011, Sebastian Bergmann <sb@sebastian-bergmann.de>.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  *   * Redistributions of source code must retain the above copyright
  13  *     notice, this list of conditions and the following disclaimer.
  14  *
  15  *   * Redistributions in binary form must reproduce the above copyright
  16  *     notice, this list of conditions and the following disclaimer in
  17  *     the documentation and/or other materials provided with the
  18  *     distribution.
  19  *
  20  *   * Neither the name of Sebastian Bergmann nor the names of his
  21  *     contributors may be used to endorse or promote products derived
  22  *     from this software without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  27  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  28  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  30  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  34  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35  * POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  * @category   PHP
  38  * @package    CodeCoverage
  39  * @author     Sebastian Bergmann <sb@sebastian-bergmann.de>
  40  * @copyright  2009-2011 Sebastian Bergmann <sb@sebastian-bergmann.de>
  41  * @license    http://www.opensource.org/licenses/bsd-license.php  BSD License
  42  * @link       http://github.com/sebastianbergmann/php-code-coverage
  43  * @since      File available since Release 1.1.0
  44  */
  45
  46 /**
  47  * Base class for nodes in the code coverage information tree.
  48  *
  49  * @category   PHP
  50  * @package    CodeCoverage
  51  * @author     Sebastian Bergmann <sb@sebastian-bergmann.de>
  52  * @copyright  2009-2011 Sebastian Bergmann <sb@sebastian-bergmann.de>
  53  * @license    http://www.opensource.org/licenses/bsd-license.php  BSD License
  54  * @version    Release: 1.1.1
  55  * @link       http://github.com/sebastianbergmann/php-code-coverage
  56  * @since      Class available since Release 1.1.0
  57  */
  58 abstract class PHP_CodeCoverage_Report_Node implements Countable
  59 {
  60     /**
  61      * @var string
  62      */
  63     protected $name;
  64
  65     /**
  66      * @var string
  67      */
  68     protected $path;
  69
  70     /**
  71      * @var array
  72      */
  73     protected $pathArray;
  74
  75     /**
  76      * @var PHP_CodeCoverage_Report_Node
  77      */
  78     protected $parent;
  79
  80     /**
  81      * @var string
  82      */
  83     protected $id;
  84
  85     /**
  86      * Constructor.
  87      *
  88      * @param string                       $name
  89      * @param PHP_CodeCoverage_Report_Node $parent
  90      */
  91     public function __construct($name, PHP_CodeCoverage_Report_Node $parent = NULL)
  92     {
  93         if (substr($name, -1) == '/') {
  94             $name = substr($name, 0, -1);
  95         }
  96
  97         $this->name   = $name;
  98         $this->parent = $parent;
  99     }
 100
 101     /**
 102      * @return string
 103      */
 104     public function getName()
 105     {
 106         return $this->name;
 107     }
 108
 109     /**
 110      * @return string
 111      */
 112     public function getId()
 113     {
 114         if ($this->id === NULL) {
 115             $parent = $this->getParent();
 116
 117             if ($parent === NULL) {
 118                 $this->id = 'index';
 119             } else {
 120                 $parentId = $parent->getId();
 121
 122                 if ($parentId == 'index') {
 123                     $this->id = $this->name;
 124                 } else {
 125                     $this->id = $parentId . '_' . $this->name;
 126                 }
 127             }
 128         }
 129
 130         return $this->id;
 131     }
 132
 133     /**
 134      * @return string
 135      */
 136     public function getPath()
 137     {
 138         if ($this->path === NULL) {
 139             if ($this->parent === NULL) {
 140                 $this->path = $this->name;
 141             } else {
 142                 $this->path = $this->parent->getPath() . '/' . $this->name;
 143             }
 144         }
 145
 146         return $this->path;
 147     }
 148
 149     /**
 150      * @return array
 151      */
 152     public function getPathAsArray()
 153     {
 154         if ($this->pathArray === NULL) {
 155             if ($this->parent === NULL) {
 156                 $this->pathArray = array();
 157             } else {
 158                 $this->pathArray = $this->parent->getPathAsArray();
 159             }
 160
 161             $this->pathArray[] = $this;
 162         }
 163
 164         return $this->pathArray;
 165     }
 166
 167     /**
 168      * @return PHP_CodeCoverage_Report_Node
 169      */
 170     public function getParent()
 171     {
 172         return $this->parent;
 173     }
 174
 175     /**
 176      * Returns the percentage of classes that has been tested.
 177      *
 178      * @param  boolean $asString
 179      * @return integer
 180      */
 181     public function getTestedClassesPercent($asString = TRUE)
 182     {
 183         return PHP_CodeCoverage_Util::percent(
 184           $this->getNumTestedClasses(),
 185           $this->getNumClasses(),
 186           $asString
 187         );
 188     }
 189
 190     /**
 191      * Returns the percentage of traits that has been tested.
 192      *
 193      * @param  boolean $asString
 194      * @return integer
 195      */
 196     public function getTestedTraitsPercent($asString = TRUE)
 197     {
 198         return PHP_CodeCoverage_Util::percent(
 199           $this->getNumTestedTraits(),
 200           $this->getNumTraits(),
 201           $asString
 202         );
 203     }
 204
 205     /**
 206      * Returns the percentage of methods that has been tested.
 207      *
 208      * @param  boolean $asString
 209      * @return integer
 210      */
 211     public function getTestedMethodsPercent($asString = TRUE)
 212     {
 213         return PHP_CodeCoverage_Util::percent(
 214           $this->getNumTestedMethods(),
 215           $this->getNumMethods(),
 216           $asString
 217         );
 218     }
 219
 220     /**
 221      * Returns the percentage of executed lines.
 222      *
 223      * @param  boolean $asString
 224      * @return integer
 225      */
 226     public function getLineExecutedPercent($asString = TRUE)
 227     {
 228         return PHP_CodeCoverage_Util::percent(
 229           $this->getNumExecutedLines(),
 230           $this->getNumExecutableLines(),
 231           $asString
 232         );
 233     }
 234
 235     /**
 236      * Returns the classes of this node.
 237      *
 238      * @return array
 239      */
 240     abstract public function getClasses();
 241
 242     /**
 243      * Returns the traits of this node.
 244      *
 245      * @return array
 246      */
 247     abstract public function getTraits();
 248
 249     /**
 250      * Returns the functions of this node.
 251      *
 252      * @return array
 253      */
 254     abstract public function getFunctions();
 255
 256     /**
 257      * Returns the LOC/CLOC/NCLOC of this node.
 258      *
 259      * @return array
 260      */
 261     abstract public function getLinesOfCode();
 262
 263     /**
 264      * Returns the number of executable lines.
 265      *
 266      * @return integer
 267      */
 268     abstract public function getNumExecutableLines();
 269
 270     /**
 271      * Returns the number of executed lines.
 272      *
 273      * @return integer
 274      */
 275     abstract public function getNumExecutedLines();
 276
 277     /**
 278      * Returns the number of classes.
 279      *
 280      * @return integer
 281      */
 282     abstract public function getNumClasses();
 283
 284     /**
 285      * Returns the number of tested classes.
 286      *
 287      * @return integer
 288      */
 289     abstract public function getNumTestedClasses();
 290
 291     /**
 292      * Returns the number of traits.
 293      *
 294      * @return integer
 295      */
 296     abstract public function getNumTraits();
 297
 298     /**
 299      * Returns the number of tested traits.
 300      *
 301      * @return integer
 302      */
 303     abstract public function getNumTestedTraits();
 304
 305     /**
 306      * Returns the number of methods.
 307      *
 308      * @return integer
 309      */
 310     abstract public function getNumMethods();
 311
 312     /**
 313      * Returns the number of tested methods.
 314      *
 315      * @return integer
 316      */
 317     abstract public function getNumTestedMethods();
 318
 319     /**
 320      * Returns the number of functions.
 321      *
 322      * @return integer
 323      */
 324     abstract public function getNumFunctions();
 325
 326     /**
 327      * Returns the number of tested functions.
 328      *
 329      * @return integer
 330      */
 331     abstract public function getNumTestedFunctions();
 332 }