All Unit tests
Current file: C:\code\midiparser\src\Midi\Util\Key.php
Legend: executed not executed dead code

  Coverage
  Classes Functions / Methods Lines
Total
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 4 / 4
 
Midi\Key
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 4 / 4
 public static function getKeySignature($accidentals, $mode)
100.00%100.00%
100.00% 1 / 1
100.00%100.00%
100.00% 3 / 3


       1                 : <?php                                                                        
       2                 :                                                                              
       3                 :     /**                                                                      
       4                 :      * \Midi\Util\Key                                                        
       5                 :      *                                                                       
       6                 :      * @package    Midi                                                      
       7                 :      * @subpackage Util                                                      
       8                 :      * @copyright  2009 Tommy Montgomery <http://phpmidiparser.com/>         
       9                 :      * @since      1.0                                                       
      10                 :      */                                                                      
      11                 :                                                                              
      12                 :     namespace Midi\Util;                                                     
      13                 :                                                                              
      14                 :     /**                                                                      
      15                 :      * Collection of constants representing the most common                  
      16                 :      * key signatures                                                        
      17                 :      *                                                                       
      18                 :      * @package    Midi                                                      
      19                 :      * @subpackage Util                                                      
      20                 :      * @since      1.0                                                       
      21                 :     */                                                                       
      22               1 :     final class Key {                                                        
      23                 :         /**                                                                  
      24                 :          * 0 flats, 0 sharps                                                 
      25                 :          *                                                                   
      26                 :          * @var string                                                       
      27                 :          */                                                                  
      28                 :         const CMajor      = '0|0';                                           
      29                 :                                                                              
      30                 :         /**                                                                  
      31                 :          * 1 sharp                                                           
      32                 :          *                                                                   
      33                 :          * @var string                                                       
      34                 :          */                                                                  
      35                 :         const GMajor      = '1|0';                                           
      36                 :         /**                                                                  
      37                 :          * 2 sharps                                                          
      38                 :          *                                                                   
      39                 :          * @var string                                                       
      40                 :          */                                                                  
      41                 :         const DMajor      = '2|0';                                           
      42                 :         /**                                                                  
      43                 :          * 3 sharps                                                          
      44                 :          *                                                                   
      45                 :          * @var string                                                       
      46                 :          */                                                                  
      47                 :         const AMajor      = '3|0';                                           
      48                 :         /**                                                                  
      49                 :          * 4 sharps                                                          
      50                 :          *                                                                   
      51                 :          * @var string                                                       
      52                 :          */                                                                  
      53                 :         const EMajor      = '4|0';                                           
      54                 :         /**                                                                  
      55                 :          * 5 sharps                                                          
      56                 :          *                                                                   
      57                 :          * @var string                                                       
      58                 :          */                                                                  
      59                 :         const BMajor      = '5|0';                                           
      60                 :         /**                                                                  
      61                 :          * 6 sharps                                                          
      62                 :          *                                                                   
      63                 :          * @var string                                                       
      64                 :          */                                                                  
      65                 :         const FSharpMajor = '6|0';                                           
      66                 :         /**                                                                  
      67                 :          * 7 sharps                                                          
      68                 :          *                                                                   
      69                 :          * @var string                                                       
      70                 :          */                                                                  
      71                 :         const CSharpMajor = '7|0';                                           
      72                 :                                                                              
      73                 :         /**                                                                  
      74                 :          * 1 flat                                                            
      75                 :          *                                                                   
      76                 :          * @var string                                                       
      77                 :          */                                                                  
      78                 :         const FMajor      = '255|0';                                         
      79                 :         /**                                                                  
      80                 :          * 2 flats                                                           
      81                 :          *                                                                   
      82                 :          * @var string                                                       
      83                 :          */                                                                  
      84                 :         const BFlatMajor  = '254|0';                                         
      85                 :         /**                                                                  
      86                 :          * 3 flats                                                           
      87                 :          *                                                                   
      88                 :          * @var string                                                       
      89                 :          */                                                                  
      90                 :         const EFlatMajor  = '253|0';                                         
      91                 :         /**                                                                  
      92                 :          * 4 flats                                                           
      93                 :          *                                                                   
      94                 :          * @var string                                                       
      95                 :          */                                                                  
      96                 :         const AFlatMajor  = '252|0';                                         
      97                 :         /**                                                                  
      98                 :          * 5 flats                                                           
      99                 :          *                                                                   
     100                 :          * @var string                                                       
     101                 :          */                                                                  
     102                 :         const DFlatMajor  = '251|0';                                         
     103                 :         /**                                                                  
     104                 :          * 6 flats                                                           
     105                 :          *                                                                   
     106                 :          * @var string                                                       
     107                 :          */                                                                  
     108                 :         const GFlatMajor  = '250|0';                                         
     109                 :         /**                                                                  
     110                 :          * 7 flats                                                           
     111                 :          *                                                                   
     112                 :          * @var string                                                       
     113                 :          */                                                                  
     114                 :         const CFlatMajor  = '249|0';                                         
     115                 :                                                                              
     116                 :         /**                                                                  
     117                 :          * 0 sharps, 0 flats                                                 
     118                 :          *                                                                   
     119                 :          * @var string                                                       
     120                 :          */                                                                  
     121                 :         const AMinor      = '0|1';                                           
     122                 :                                                                              
     123                 :         /**                                                                  
     124                 :          * 1 sharp                                                           
     125                 :          *                                                                   
     126                 :          * @var string                                                       
     127                 :          */                                                                  
     128                 :         const EMinor      = '1|1';                                           
     129                 :         /**                                                                  
     130                 :          * 2 sharps                                                          
     131                 :          *                                                                   
     132                 :          * @var string                                                       
     133                 :          */                                                                  
     134                 :         const BMinor      = '2|1';                                           
     135                 :         /**                                                                  
     136                 :          * 3 sharps                                                          
     137                 :          *                                                                   
     138                 :          * @var string                                                       
     139                 :          */                                                                  
     140                 :         const FSharpMinor = '3|1';                                           
     141                 :         /**                                                                  
     142                 :          * 4 sharps                                                          
     143                 :          *                                                                   
     144                 :          * @var string                                                       
     145                 :          */                                                                  
     146                 :         const CSharpMinor = '4|1';                                           
     147                 :         /**                                                                  
     148                 :          * 5 sharps                                                          
     149                 :          *                                                                   
     150                 :          * @var string                                                       
     151                 :          */                                                                  
     152                 :         const GSharpMinor = '5|1';                                           
     153                 :         /**                                                                  
     154                 :          * 6 sharps                                                          
     155                 :          *                                                                   
     156                 :          * @var string                                                       
     157                 :          */                                                                  
     158                 :         const DSharpMinor = '6|1';                                           
     159                 :         /**                                                                  
     160                 :          * 7 sharps                                                          
     161                 :          *                                                                   
     162                 :          * @var string                                                       
     163                 :          */                                                                  
     164                 :         const ASharpMinor = '7|1';                                           
     165                 :                                                                              
     166                 :         /**                                                                  
     167                 :          * 1 flat                                                            
     168                 :          *                                                                   
     169                 :          * @var string                                                       
     170                 :          */                                                                  
     171                 :         const DMinor      = '249|1';                                         
     172                 :         /**                                                                  
     173                 :          * 2 flats                                                           
     174                 :          *                                                                   
     175                 :          * @var string                                                       
     176                 :          */                                                                  
     177                 :         const GMinor      = '250|1';                                         
     178                 :         /**                                                                  
     179                 :          * 3 flats                                                           
     180                 :          *                                                                   
     181                 :          * @var string                                                       
     182                 :          */                                                                  
     183                 :         const CMinor      = '251|1';                                         
     184                 :         /**                                                                  
     185                 :          * 4 flats                                                           
     186                 :          *                                                                   
     187                 :          * @var string                                                       
     188                 :          */                                                                  
     189                 :         const FMinor      = '252|1';                                         
     190                 :         /**                                                                  
     191                 :          * 5 flats                                                           
     192                 :          *                                                                   
     193                 :          * @var string                                                       
     194                 :          */                                                                  
     195                 :         const BFlatMinor  = '253|1';                                         
     196                 :         /**                                                                  
     197                 :          * 6 flats                                                           
     198                 :          *                                                                   
     199                 :          * @var string                                                       
     200                 :          */                                                                  
     201                 :         const EFlatMinor = '254|1';                                          
     202                 :         /**                                                                  
     203                 :          * 7 flats                                                           
     204                 :          *                                                                   
     205                 :          * @var string                                                       
     206                 :          */                                                                  
     207                 :         const AFlatMinor  = '255|1';                                         
     208                 :                                                                              
     209                 :         private static $keyMap = array(                                      
     210                 :             self::CMajor       => 'C Major',                                 
     211                 :             self::GMajor       => 'G Major',                                 
     212                 :             self::DMajor       => 'D Major',                                 
     213                 :             self::AMajor       => 'A Major',                                 
     214                 :             self::EMajor       => 'E Major',                                 
     215                 :             self::BMajor       => 'B Major',                                 
     216                 :             self::FSharpMajor  => 'F# Major',                                
     217                 :             self::CSharpMajor  => 'C# Major',                                
     218                 :                                                                              
     219                 :             self::FMajor       => 'F Major',                                 
     220                 :             self::BFlatMajor   => 'Bb Major',                                
     221                 :             self::EFlatMajor   => 'Eb Major',                                
     222                 :             self::AFlatMajor   => 'Ab Major',                                
     223                 :             self::DFlatMajor   => 'Db Major',                                
     224                 :             self::GFlatMajor   => 'Gb Major',                                
     225                 :             self::CFlatMajor   => 'Cb Major',                                
     226                 :                                                                              
     227                 :             self::AMinor       => 'A Minor',                                 
     228                 :             self::EMinor       => 'E Minor',                                 
     229                 :             self::BMinor       => 'B Minor',                                 
     230                 :             self::FSharpMinor  => 'F# Minor',                                
     231                 :             self::CSharpMinor  => 'C# Minor',                                
     232                 :             self::GSharpMinor  => 'G# Minor',                                
     233                 :             self::DSharpMinor  => 'D# Minor',                                
     234                 :             self::ASharpMinor  => 'A# Minor',                                
     235                 :                                                                              
     236                 :             self::DMinor       => 'D Minor',                                 
     237                 :             self::GMinor       => 'G Minor',                                 
     238                 :             self::CMinor       => 'C Minor',                                 
     239                 :             self::FMinor       => 'F Minor',                                 
     240                 :             self::BFlatMinor   => 'Bb Minor',                                
     241                 :             self::EFlatMinor   => 'Eb Minor',                                
     242                 :             self::AFlatMinor   => 'Ab Minor'                                 
     243                 :         );                                                                   
     244                 :                                                                              
     245                 :         /**                                                                  
     246                 :          * Gets the friendly name of the key signature                       
     247                 :          *                                                                   
     248                 :          * @since 1.0                                                        
     249                 :          *                                                                   
     250                 :          * @param  int $accidentals 0 + # of sharps or 256 - # of flats      
     251                 :          * @param  int $mode        0 for major, 1 for minor                 
     252                 :          * @throws InvalidArgumentException                                  
     253                 :          * @return string                                                    
     254                 :          */                                                                  
     255                 :         public static function getKeySignature($accidentals, $mode) {        
     256               3 :             if (!isset(self::$keyMap[$accidentals . '|' . $mode])) {         
     257               1 :                 throw new \InvalidArgumentException('Invalid key signature');
     258                 :             }                                                                
     259                 :                                                                              
     260               2 :             return self::$keyMap[$accidentals . '|' . $mode];                
     261                 :         }                                                                    
     262                 :     }                                                                        
     263                 :                                                                              

Generated by PHPUnit 3.4.1 and Xdebug 2.0.5 using PHP 5.3.0 at Sun Oct 25 23:35:09 PDT 2009.