Login   Register  
PHP Classes
elePHPant
Icontem

File: ComplexityAnalyzerTest.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  Classes of Philipp Strazny  >  Complexity Analyzer  >  ComplexityAnalyzerTest.php  >  Download  
File: ComplexityAnalyzerTest.php
Role: Unit test script
Content type: text/plain
Description: tests the methods of ComplexityAnalyzer
Class: Complexity Analyzer
Evaluate the complexity of classes' code
Author: By
Last change: changed listing priority
Date: 2 years ago
Size: 8,156 bytes
 

Contents

Class file image Download
<?php

require_once 'ComplexityAnalyzer.php';
require_once 
'DummyClass.php';
require_once 
'DummyClassTest.php';

/**
 * Test class for ComplexityAnalyzer.
 * Generated by PHPUnit on 2011-12-30 at 16:16:39.
 */
class ComplexityAnalyzerTest extends PHPUnit_Framework_TestCase
{
    
/**
     * @var ComplexityAnalyzer
     */
    
protected $object;
    
/**
     * @var ComplexityAnalyzer ReflectionClass
     */
    
protected $testclass;

    
/**
     * This method is called before a test is executed.
     * I started writing tests applying ComplexityAnalyzer to itself
     * but that gets mindboggling at times, like reading
     * Derrida's writing about writing, where the text is about itself
     * When I could not take it anymore, I stopped doing that and introduced
     * the external DummyClass - much easier.
     */
    
protected function setUp()
    {
        
$this->object = new ComplexityAnalyzer('ComplexityAnalyzer''ComplexityAnalyzer.php');
        
$this->testclass = new ReflectionClass('ComplexityAnalyzer');
    }
    
    
/**
     * @covers ComplexityAnalyzer::__construct
     */
    
public function test__construct(){
        
$this->assertTrue(isset($this->object)); // result of call without testclass
        // now check with testclass
        
$ca = new ComplexityAnalyzer('DummyClass''DummyClass.php');
        
$this->assertTrue(isset($ca));
        
// now check with bad path
        
try{
            
$ca = new ComplexityAnalyzer('DummyClass''BADDummyClass.php');
        }
        catch(
Exception $e){
            return;
        }
        
$this->fail();
    }


    
/**
     * @covers ComplexityAnalyzer::getMethods
     */
    
public function testGetMethods()
    {
        
$methods $this->object->getMethods();
        
$this->assertTrue(count($methods)>5); //some not-too-small number
        
$this->assertTrue($methods[0] instanceof ReflectionMethod);
    }

    
/**
     * @covers ComplexityAnalyzer::getMethodSource
     */
    
public function testGetMethodSource()
    {
        
$method $this->object->getClassMethod('getClassMethod');
        
$methodsource $this->object->getMethodSource($method);
        
$this->assertRegExp('/getClassMethod\s*\([^)]*\)\s*{.*}/s'$methodsource);
    }

    
/**
     * @covers ComplexityAnalyzer::getClassMethod
     */
    
public function testGetClassMethod()
    {
        
$method $this->object->getClassMethod('getClassMethod');
        
$this->assertTrue($method instanceof ReflectionMethod);
        
$this->assertEquals($method->name'getClassMethod');
    }

    
/**
     * @covers ComplexityAnalyzer::getNumberOfParentheses
     */
    
public function testGetNumberOfParentheses()
    {
        
$numparens $this->object->getNumberOfParentheses('getClassMethod');
        
$this->assertEquals($numparens2); // 1 paren for arg list, 1 within body 
    
}
    
/**
     * @covers ComplexityAnalyzer::renderTodoList
     */
    
public function testRenderTodoList()
    {
        
$list = array('a''b''c');
        
$renderedlist $this->object->renderTodoList($list);
        
$this->assertRegExp('/3: c/'$renderedlist); // 1 paren for arg list, 1 within body 
    
}
    
/**
     * @covers ComplexityAnalyzer::convertToTestMethodName
     */
    
public function testConvertToTestMethodName()
    {
        
$name 'someName';
        
$expectedname 'testSomeName';
        
$this->assertEquals($this->object->convertToTestMethodName($name), $expectedname);
    }
    
/**
     * @covers ComplexityAnalyzer::convertToMethodName
     */
    
public function testConvertToMethodName()
    {
        
$name 'testSomeName';
        
$expectedname 'someName';
        
$this->assertEquals($this->object->convertToMethodName($name), $expectedname);
    }
    
/**
     * @covers ComplexityAnalyzer::convertToMethodName
     */
    
public function testConvertToMethodName_withBadArg()
    {
        
$name 'someBadName';
        
$expectedname '';
        
$this->assertEquals($this->object->convertToMethodName($name), $expectedname); 
    }

    
/**
     * @covers ComplexityAnalyzer::getMethodDependencies
     */
    
public function testGetMethodDependencies()
    {
        
$dependencies $this->object->getMethodDependencies();
        
$expectedmethods = array('getClassMethod''getMethodSource');
        
//print_r($dependencies['getCalledMethods']);
        
$this->assertEmpty(array_diff($expectedmethods$dependencies['getNumberOfParentheses']));
    }
    
/**
     * @covers ComplexityAnalyzer::makeToDoList
     */
    
public function testMakeToDoList()
    {
        
$dependencies = array('a'=>5'b'=>10'c'=>15);
        
$incompletemethods = array('z''c''a');
        
$list $this->object->makeToDoList($dependencies$incompletemethods);
        
$this->assertEquals($list, array('a''c'));
    }

    
/**
     * @covers ComplexityAnalyzer::getMethodDependencyScores
     */
    
public function testGetMethodDependencyScores()
    {
        
$ca = new ComplexityAnalyzer('DummyClass''DummyClass.php');
        
$dependencyScores $ca->getMethodDependencyScores();
        
//print_r($dependencyScores);
        
$expected = array(
            
'levelOneA'=>1// 1 paren
            
'levelOneB'=>2// 2 parens
            
'levelTwo'=>3,  // 2 parens + levelOneA's score
            
'levelThree'=>// 2 parens + levelTwo's score
            
);
        
$this->assertEquals($dependencyScores$expected);
        
    }
    
/**
     * @covers ComplexityAnalyzer::getCompositeScore
     */
    
public function testGetCompositeScore()
    {
        
$ca = new ComplexityAnalyzer('DummyClass''DummyClass.php');
        
$dependencies $ca->getMethodDependencies();
        
$score $ca->getCompositeScore($dependencies'levelOneA');
        
$this->assertEquals($score1);
        
$score $ca->getCompositeScore($dependencies'levelTwo');
        
$this->assertEquals($score3);
        
$score $ca->getCompositeScore($dependencies'levelThree');
        
$this->assertEquals($score5);
        
// check on recursion:
        
$seen = array('levelThree'=>123);
        
$score $ca->getCompositeScore($dependencies'levelThree'$seen);
        
$this->assertEquals($score123);
        
    }

    
/**
     * @covers ComplexityAnalyzer::getCalledMethods
     */
    
public function testGetCalledMethods()
    {
        
$this->object = new ComplexityAnalyzer('DummyClass''DummyClass.php');
        
$this->testclass = new ReflectionClass('DummyClass');
        
$method $this->getMethod('levelTwo');        
        
$calledmethods $this->object->getCalledMethods($method);
        
$this->assertEquals($calledmethods, array('levelOneA'));
    }

    
/**
     * @covers ComplexityAnalyzer::getIncompleteMethods
     */
    
public function testGetIncompleteMethods()
    {
        
$ca = new ComplexityAnalyzer('DummyClass''DummyClass.php');
        
$caTest = new ComplexityAnalyzer('DummyClassTest''DummyClassTest.php');
        
$testmethods $caTest->getMethods();
        
$incompletemethods $ca->getIncompleteMethods($testmethods$caTest);
        
$expected = array('levelOneA''levelOneB''levelTwo');
        
$this->assertEquals($incompletemethods$expected);
    }
        

    
/**
     * @covers ComplexityAnalyzer::getToDoList
     */
    
public function testGetToDoList()
    {
        
$ca = new ComplexityAnalyzer('DummyClass''DummyClass.php');
        
$caTest = new ComplexityAnalyzer('DummyClassTest''DummyClassTest.php');
        
$testmethods $caTest->getMethods();
        
$dependencyScores $ca->getMethodDependencyScores();
        
$expected = array('levelOneA''levelOneB''levelTwo');
        
$todolist $ca->getToDoList($dependencyScores$testmethods$caTest);
        
//print_r($todolist);
        
$this->assertEquals($todolist$expected);
    }
    
/**
     * retrieves method by name and allows to use it
     * even if it is not public
     * @return a "publicized" ReflectionMethod
     */  
    
protected function getMethod($name) {
      
$method $this->testclass->getMethod($name);
      
$method->setAccessible(true);
      return 
$method;
    }
    
/**
     * retrieves value of class property even if the class
     * property is not public
     * @return a "publicized" property
     */  
    
protected function getProperty($name) {
      
$property $this->testclass->getProperty($name);
      
$property->setAccessible(true);
      return 
$property->getValue($this->object);      
    }
}
?>