LoggerLevel.php
Current file: /home/ihabunek/apache/log4php/src/main/php/LoggerLevel.php
Legend: executed not executed dead code

  Coverage
  Classes Functions / Methods Lines
Total
0.00% 0 / 1
87.50% 14 / 16 CRAP
95.65% 66 / 69
LoggerLevel
0.00% 0 / 1
87.50% 14 / 16 43
95.65% 66 / 69
 __construct($level, $levelStr, $syslogEquivalent)
100.00% 1 / 1 1
100.00% 4 / 4
 equals($other)
0.00% 0 / 1 3.04
83.33% 5 / 6
 getLevelOff()
100.00% 1 / 1 2
100.00% 4 / 4
 getLevelFatal()
100.00% 1 / 1 2
100.00% 4 / 4
 getLevelError()
100.00% 1 / 1 2
100.00% 4 / 4
 getLevelWarn()
100.00% 1 / 1 2
100.00% 4 / 4
 getLevelInfo()
100.00% 1 / 1 2
100.00% 4 / 4
 getLevelDebug()
100.00% 1 / 1 2
100.00% 4 / 4
 getLevelTrace()
100.00% 1 / 1 2
100.00% 4 / 4
 getLevelAll()
100.00% 1 / 1 2
100.00% 4 / 4
 getSyslogEquivalent()
100.00% 1 / 1 1
100.00% 1 / 1
 isGreaterOrEqual($other)
100.00% 1 / 1 1
100.00% 1 / 1
 toString()
100.00% 1 / 1 1
100.00% 1 / 1
 __toString()
100.00% 1 / 1 1
100.00% 1 / 1
 toInt()
100.00% 1 / 1 1
100.00% 1 / 1
 toLevel($arg, $defaultLevel = null)
0.00% 0 / 1 18.24
90.91% 20 / 22


       1                 : <?php                                                                                                     
       2                 : /**                                                                                                       
       3                 :  * Licensed to the Apache Software Foundation (ASF) under one or more                                     
       4                 :  * contributor license agreements. See the NOTICE file distributed with                                   
       5                 :  * this work for additional information regarding copyright ownership.                                    
       6                 :  * The ASF licenses this file to You under the Apache License, Version 2.0                                
       7                 :  * (the "License"); you may not use this file except in compliance with                                   
       8                 :  * the License. You may obtain a copy of the License at                                                   
       9                 :  *                                                                                                        
      10                 :  *       http://www.apache.org/licenses/LICENSE-2.0                                                       
      11                 :  *                                                                                                        
      12                 :  * Unless required by applicable law or agreed to in writing, software                                    
      13                 :  * distributed under the License is distributed on an "AS IS" BASIS,                                      
      14                 :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.                               
      15                 :  * See the License for the specific language governing permissions and                                    
      16                 :  * limitations under the License.                                                                         
      17                 :  *                                                                                                        
      18                 :  * @package log4php                                                                                       
      19                 :  */                                                                                                       
      20                 :                                                                                                           
      21                 : /**                                                                                                       
      22                 :  * Defines the minimum set of levels recognized by the system, that is                                    
      23                 :  * <i>OFF</i>, <i>FATAL</i>, <i>ERROR</i>,                                                                
      24                 :  * <i>WARN</i>, <i>INFO</i>, <i>DEBUG</i> and                                                             
      25                 :  * <i>ALL</i>.                                                                                            
      26                 :  *                                                                                                        
      27                 :  * <p>The <i>LoggerLevel</i> class may be subclassed to define a larger                                   
      28                 :  * level set.</p>                                                                                         
      29                 :  *                                                                                                        
      30                 :  * @version $Revision: 1230524 $                                                                          
      31                 :  * @package log4php                                                                                       
      32                 :  * @since 0.5                                                                                             
      33                 :  */                                                                                                       
      34                 : class LoggerLevel {                                                                                       
      35                 :                                                                                                           
      36                 :     const OFF = 2147483647;                                                                               
      37                 :     const FATAL = 50000;                                                                                  
      38                 :     const ERROR = 40000;                                                                                  
      39                 :     const WARN = 30000;                                                                                   
      40                 :     const INFO = 20000;                                                                                   
      41                 :     const DEBUG = 10000;                                                                                  
      42                 :     const TRACE = 5000;                                                                                   
      43                 :     const ALL = -2147483647;                                                                              
      44                 :                                                                                                           
      45                 :     /** Integer level value. */                                                                           
      46                 :     private $level;                                                                                       
      47                 :                                                                                                           
      48                 :     /** Contains a list of instantiated levels. */                                                        
      49                 :     private static $levelMap;                                                                             
      50                 :                                                                                                           
      51                 :     /** String representation of the level. */                                                            
      52                 :     private $levelStr;                                                                                    
      53                 :                                                                                                           
      54                 :     /**                                                                                                   
      55                 :      * Equivalent syslog level.                                                                           
      56                 :      * @var integer                                                                                       
      57                 :      */                                                                                                   
      58                 :     private $syslogEquivalent;                                                                            
      59                 :                                                                                                           
      60                 :     /**                                                                                                   
      61                 :      * Constructor                                                                                        
      62                 :      *                                                                                                    
      63                 :      * @param integer $level                                                                              
      64                 :      * @param string $levelStr                                                                            
      65                 :      * @param integer $syslogEquivalent                                                                   
      66                 :      */                                                                                                   
      67                 :     private function __construct($level, $levelStr, $syslogEquivalent) {                                  
      68               4 :         $this->level = $level;                                                                            
      69               4 :         $this->levelStr = $levelStr;                                                                      
      70               4 :         $this->syslogEquivalent = $syslogEquivalent;                                                      
      71               4 :     }                                                                                                     
      72                 :                                                                                                           
      73                 :     /**                                                                                                   
      74                 :      * Compares two logger levels.                                                                        
      75                 :      *                                                                                                    
      76                 :      * @param LoggerLevels $other                                                                         
      77                 :      * @return boolean                                                                                    
      78                 :      */                                                                                                   
      79                 :     public function equals($other) {                                                                      
      80               6 :         if($other instanceof LoggerLevel) {                                                               
      81               6 :             if($this->level == $other->level) {                                                           
      82               5 :                 return true;                                                                              
      83                 :             }                                                                                             
      84               6 :         } else {                                                                                          
      85               0 :             return false;                                                                                 
      86                 :         }                                                                                                 
      87               6 :     }                                                                                                     
      88                 :                                                                                                           
      89                 :     /**                                                                                                   
      90                 :      * Returns an Off Level                                                                               
      91                 :      * @return LoggerLevel                                                                                
      92                 :      */                                                                                                   
      93                 :     public static function getLevelOff() {                                                                
      94               1 :         if(!isset(self::$levelMap[LoggerLevel::OFF])) {                                                   
      95               1 :             self::$levelMap[LoggerLevel::OFF] = new LoggerLevel(LoggerLevel::OFF, 'OFF', LOG_ALERT);      
      96               1 :         }                                                                                                 
      97               1 :         return self::$levelMap[LoggerLevel::OFF];                                                         
      98                 :     }                                                                                                     
      99                 :                                                                                                           
     100                 :     /**                                                                                                   
     101                 :      * Returns a Fatal Level                                                                              
     102                 :      * @return LoggerLevel                                                                                
     103                 :      */                                                                                                   
     104                 :     public static function getLevelFatal() {                                                              
     105              14 :         if(!isset(self::$levelMap[LoggerLevel::FATAL])) {                                                 
     106               1 :             self::$levelMap[LoggerLevel::FATAL] = new LoggerLevel(LoggerLevel::FATAL, 'FATAL', LOG_ALERT);
     107               1 :         }                                                                                                 
     108              14 :         return self::$levelMap[LoggerLevel::FATAL];                                                       
     109                 :     }                                                                                                     
     110                 :                                                                                                           
     111                 :     /**                                                                                                   
     112                 :      * Returns an Error Level                                                                             
     113                 :      * @return LoggerLevel                                                                                
     114                 :      */                                                                                                   
     115                 :     public static function getLevelError() {                                                              
     116              50 :         if(!isset(self::$levelMap[LoggerLevel::ERROR])) {                                                 
     117               1 :             self::$levelMap[LoggerLevel::ERROR] = new LoggerLevel(LoggerLevel::ERROR, 'ERROR', LOG_ERR);  
     118               1 :         }                                                                                                 
     119              50 :         return self::$levelMap[LoggerLevel::ERROR];                                                       
     120                 :     }                                                                                                     
     121                 :                                                                                                           
     122                 :     /**                                                                                                   
     123                 :      * Returns a Warn Level                                                                               
     124                 :      * @return LoggerLevel                                                                                
     125                 :      */                                                                                                   
     126                 :     public static function getLevelWarn() {                                                               
     127              40 :         if(!isset(self::$levelMap[LoggerLevel::WARN])) {                                                  
     128               1 :             self::$levelMap[LoggerLevel::WARN] = new LoggerLevel(LoggerLevel::WARN, 'WARN', LOG_WARNING); 
     129               1 :         }                                                                                                 
     130              40 :         return self::$levelMap[LoggerLevel::WARN];                                                        
     131                 :     }                                                                                                     
     132                 :                                                                                                           
     133                 :     /**                                                                                                   
     134                 :      * Returns an Info Level                                                                              
     135                 :      * @return LoggerLevel                                                                                
     136                 :      */                                                                                                   
     137                 :     public static function getLevelInfo() {                                                               
     138              32 :         if(!isset(self::$levelMap[LoggerLevel::INFO])) {                                                  
     139               1 :             self::$levelMap[LoggerLevel::INFO] = new LoggerLevel(LoggerLevel::INFO, 'INFO', LOG_INFO);    
     140               1 :         }                                                                                                 
     141              32 :         return self::$levelMap[LoggerLevel::INFO];                                                        
     142                 :     }                                                                                                     
     143                 :                                                                                                           
     144                 :     /**                                                                                                   
     145                 :      * Returns a Debug Level                                                                              
     146                 :      * @return LoggerLevel                                                                                
     147                 :      */                                                                                                   
     148                 :     public static function getLevelDebug() {                                                              
     149              84 :         if(!isset(self::$levelMap[LoggerLevel::DEBUG])) {                                                 
     150               1 :             self::$levelMap[LoggerLevel::DEBUG] = new LoggerLevel(LoggerLevel::DEBUG, 'DEBUG', LOG_DEBUG);
     151               1 :         }                                                                                                 
     152              84 :         return self::$levelMap[LoggerLevel::DEBUG];                                                       
     153                 :     }                                                                                                     
     154                 :                                                                                                           
     155                 :     /**                                                                                                   
     156                 :      * Returns a Trace Level                                                                              
     157                 :      * @return LoggerLevel                                                                                
     158                 :      */                                                                                                   
     159                 :     public static function getLevelTrace() {                                                              
     160              12 :         if(!isset(self::$levelMap[LoggerLevel::TRACE])) {                                                 
     161               1 :             self::$levelMap[LoggerLevel::TRACE] = new LoggerLevel(LoggerLevel::TRACE, 'TRACE', LOG_DEBUG);
     162               1 :         }                                                                                                 
     163              12 :         return self::$levelMap[LoggerLevel::TRACE];                                                       
     164                 :     }                                                                                                     
     165                 :                                                                                                           
     166                 :     /**                                                                                                   
     167                 :      * Returns an All Level                                                                               
     168                 :      * @return LoggerLevel                                                                                
     169                 :      */                                                                                                   
     170                 :     public static function getLevelAll() {                                                                
     171              75 :         if(!isset(self::$levelMap[LoggerLevel::ALL])) {                                                   
     172               1 :             self::$levelMap[LoggerLevel::ALL] = new LoggerLevel(LoggerLevel::ALL, 'ALL', LOG_DEBUG);      
     173               1 :         }                                                                                                 
     174              75 :         return self::$levelMap[LoggerLevel::ALL];                                                         
     175                 :     }                                                                                                     
     176                 :                                                                                                           
     177                 :     /**                                                                                                   
     178                 :      * Return the syslog equivalent of this priority as an integer.                                       
     179                 :      * @return integer                                                                                    
     180                 :      */                                                                                                   
     181                 :     public function getSyslogEquivalent() {                                                               
     182               9 :         return $this->syslogEquivalent;                                                                   
     183                 :     }                                                                                                     
     184                 :                                                                                                           
     185                 :     /**                                                                                                   
     186                 :      * Returns <i>true</i> if this level has a higher or equal                                            
     187                 :      * level than the level passed as argument, <i>false</i>                                              
     188                 :      * otherwise.                                                                                         
     189                 :      *                                                                                                    
     190                 :      * @param LoggerLevel $other                                                                          
     191                 :      * @return boolean                                                                                    
     192                 :      */                                                                                                   
     193                 :     public function isGreaterOrEqual($other) {                                                            
     194              26 :         return $this->level >= $other->level;                                                             
     195                 :     }                                                                                                     
     196                 :                                                                                                           
     197                 :     /**                                                                                                   
     198                 :      * Returns the string representation of this level.                                                   
     199                 :      * @return string                                                                                     
     200                 :      */                                                                                                   
     201                 :     public function toString() {                                                                          
     202              62 :         return $this->levelStr;                                                                           
     203                 :     }                                                                                                     
     204                 :                                                                                                           
     205                 :     /**                                                                                                   
     206                 :      * Returns the string representation of this level.                                                   
     207                 :      * @return string                                                                                     
     208                 :      */                                                                                                   
     209                 :     public function __toString() {                                                                        
     210              30 :         return $this->toString();                                                                         
     211                 :     }                                                                                                     
     212                 :                                                                                                           
     213                 :     /**                                                                                                   
     214                 :      * Returns the integer representation of this level.                                                  
     215                 :      * @return integer                                                                                    
     216                 :      */                                                                                                   
     217                 :     public function toInt() {                                                                             
     218              10 :         return $this->level;                                                                              
     219                 :     }                                                                                                     
     220                 :                                                                                                           
     221                 :     /**                                                                                                   
     222                 :      * Convert the input argument to a level. If the conversion fails, then                               
     223                 :      * this method returns the provided default level.                                                    
     224                 :      *                                                                                                    
     225                 :      * @param mixed $arg The value to convert to level.                                                   
     226                 :      * @param LoggerLevel $default Value to return if conversion is not possible.                         
     227                 :      * @return LoggerLevel                                                                                
     228                 :      */                                                                                                   
     229                 :     public static function toLevel($arg, $defaultLevel = null) {                                          
     230              43 :         if(is_int($arg)) {                                                                                
     231                 :             switch($arg) {                                                                                
     232               8 :                 case self::ALL:    return self::getLevelAll();                                            
     233               7 :                 case self::TRACE: return self::getLevelTrace();                                           
     234               6 :                 case self::DEBUG: return self::getLevelDebug();                                           
     235               5 :                 case self::INFO: return self::getLevelInfo();                                             
     236               4 :                 case self::WARN: return self::getLevelWarn();                                             
     237               3 :                 case self::ERROR: return self::getLevelError();                                           
     238               2 :                 case self::FATAL: return self::getLevelFatal();                                           
     239               1 :                 case self::OFF:    return self::getLevelOff();                                            
     240               0 :                 default: return $defaultLevel;                                                            
     241               0 :             }                                                                                             
     242                 :         } else {                                                                                          
     243              43 :             switch(strtoupper($arg)) {                                                                    
     244              43 :                 case 'ALL':    return self::getLevelAll();                                                
     245              42 :                 case 'TRACE': return self::getLevelTrace();                                               
     246              40 :                 case 'DEBUG': return self::getLevelDebug();                                               
     247              25 :                 case 'INFO': return self::getLevelInfo();                                                 
     248              21 :                 case 'WARN': return self::getLevelWarn();                                                 
     249              17 :                 case 'ERROR': return self::getLevelError();                                               
     250               7 :                 case 'FATAL': return self::getLevelFatal();                                               
     251               5 :                 case 'OFF':    return self::getLevelOff();                                                
     252               4 :                 default: return $defaultLevel;                                                            
     253               4 :             }                                                                                             
     254                 :         }                                                                                                 
     255                 :     }                                                                                                     
     256                 : }                                                                                                         

Generated by PHP_CodeCoverage 1.1.1 using PHP 5.3.3-7+squeeze3 and PHPUnit 3.6.3 at Sat Feb 18 22:32:39 GMT 2012.