Changeset 50

Show
Ignore:
Timestamp:
12/23/02 12:46:37 (6 years ago)
Author:
rentzsch
Message:

First Imported.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/wolf/TestingAppender/TestingAppender.java

    r37 r50  
    22// 
    33// Copyright (c) 2001 Red Shed Software. All rights reserved. 
    4 // by Jonathan 'Wolf' Rentzsch (jon at redshed dot net) 
     4// by Jonathan 'Wolf' Rentzsch (jon * redshed * net) 
    55// 
    66// Mon Dec 31 2001 wolf: Created. 
    …… 
    99import org.apache.log4j.*; 
    1010 
     11/** 
     12 * A custom appender meant for use with unit tests. When activated, it captures 
     13 * all logging output and remembers the priority of the messages logged. For 
     14 * example, this enables you to pass known bad data to a black box and then test 
     15 * to make sure that an error was logged. 
     16 */ 
    1117public class TestingAppender extends AppenderSkeleton { 
    1218        private org.apache.log4j.Logger _logger; 
    1319        private Vector _appenders = new Vector(); 
    1420        private Priority _priority = null; 
    15         private boolean _debugFired,_infoFired,_warnFired,_errorFired; 
     21       private boolean _debugFired, _infoFired, _warnFired, _errorFired; 
    1622 
    17         public TestingAppender( Logger logger ) { 
    18             super(); 
     23        /** 
     24         * When constructed, saves off all existing appenders, removes them and adds 
     25         * itself. When done, use the release() method to restore the previous 
     26         * appender set. 
     27         * @param logger The logger to overtake with our sole custom appender. If 
     28         * null, uses Logger.getRoot(). 
     29         */ 
     30        public TestingAppender(Logger logger) { 
     31                super(); 
    1932 
    20             _debugFired = false; 
    21             _infoFired = false; 
    22             _warnFired = false; 
    23             _errorFired = false; 
    24              
    25             if( logger == null ) 
    26                 logger = (Logger)Logger.getRoot(); 
    27             _logger = logger; 
    28                         // Save off all existing appenders, remove them all and add ourself. 
    29             java.util.Enumeration enumeration = _logger.getAllAppenders(); 
    30             while( enumeration.hasMoreElements() ) { 
    31                 Appender currentAppender = (Appender) enumeration.nextElement(); 
    32                 System.out.println( "saving off appender "+currentAppender ); 
    33                 _appenders.addElement( currentAppender ); 
    34                 _logger.removeAppender ( currentAppender ); 
    35             } 
    36             _logger.addAppender( this ); 
    37         } 
    38          
    39         public void release() { 
    40             // Remove ourself and restore the previous appender list. 
    41             _logger.removeAppender( this ); 
    42             java.util.Enumeration enumeration = _appenders.elements(); 
    43             while( enumeration.hasMoreElements() ) { 
    44                 Appender currentAppender = (Appender) enumeration.nextElement(); 
    45                 System.out.println( "restoring appender "+currentAppender ); 
    46                 _logger.addAppender( currentAppender ); 
    47             } 
    48         } 
    49          
    50         protected void append( org.apache.log4j.spi.LoggingEvent event ) { 
    51             if ( event.level.toInt() == Priority.DEBUG.toInt() ) _debugFired = true; 
    52             if ( event.level.toInt() == Priority.INFO.toInt() ) _infoFired = true; 
    53             if ( event.level.toInt() == Priority.WARN.toInt() ) _warnFired = true; 
    54             if ( event.level.toInt() == Priority.ERROR.toInt() ) _errorFired = true;             
    55         } 
    56          
    57         public void close() {} 
    58          
     33                _debugFired = false; 
     34                _infoFired = false; 
     35                _warnFired = false; 
     36                _errorFired = false; 
     37 
     38                if (logger == null) 
     39                        logger = (Logger) Logger.getRoot(); 
     40                _logger = logger; 
     41                java.util.Enumeration enumeration = _logger.getAllAppenders(); 
     42                while (enumeration.hasMoreElements()) { 
     43                        Appender currentAppender = (Appender) enumeration.nextElement(); 
     44                        System.out.println("saving off appender " + currentAppender); 
     45                        _appenders.addElement(currentAppender); 
     46                        _logger.removeAppender(currentAppender); 
     47                } 
     48                _logger.addAppender(this); 
     49        } 
     50 
     51        /** 
     52         * Removes this appender and restores the previously saved off appenders. 
     53         */ 
     54        public void release() { 
     55                _logger.removeAppender(this); 
     56                java.util.Enumeration enumeration = _appenders.elements(); 
     57                while (enumeration.hasMoreElements()) { 
     58                        Appender currentAppender = (Appender) enumeration.nextElement(); 
     59                        System.out.println("restoring appender " + currentAppender); 
     60                        _logger.addAppender(currentAppender); 
     61                } 
     62        } 
     63 
     64        protected void append(org.apache.log4j.spi.LoggingEvent event) { 
     65                if (event.level.toInt() == Priority.DEBUG.toInt()) 
     66                        _debugFired = true; 
     67                if (event.level.toInt() == Priority.INFO.toInt()) 
     68                        _infoFired = true; 
     69                if (event.level.toInt() == Priority.WARN.toInt()) 
     70                        _warnFired = true; 
     71                if (event.level.toInt() == Priority.ERROR.toInt()) 
     72                        _errorFired = true; 
     73        } 
     74 
     75        public void close() { 
     76        } 
     77 
    5978        public boolean requiresLayout() { 
    6079                return false; 
    6180        } 
    62          
     81 
    6382        public boolean anyFired() { 
    64             return _debugFired || _infoFired || _warnFired || _errorFired; 
    65         } 
    66                  
     83               return _debugFired || _infoFired || _warnFired || _errorFired; 
     84       } 
     85 
    6786        public boolean debugFired() { 
    68             return _debugFired; 
    69         } 
    70                  
     87               return _debugFired; 
     88       } 
     89 
    7190        public boolean infoFired() { 
    72             return _infoFired; 
    73         } 
    74                  
     91               return _infoFired; 
     92       } 
     93 
    7594        public boolean warnFired() { 
    76             return _warnFired; 
    77         } 
    78                  
     95               return _warnFired; 
     96       } 
     97 
    7998        public boolean errorFired() { 
    80             return _errorFired; 
    81         } 
    82          
    83         public Priority greatestFired () { 
    84             if ( errorFired() ) return Priority.ERROR; 
    85             if ( warnFired() ) return Priority.WARN; 
    86             if ( infoFired() ) return Priority.INFO; 
    87             if ( debugFired() ) return Priority.DEBUG; 
    88             return null; 
    89         } 
     99                return _errorFired; 
     100        } 
    90101 
    91         public boolean isClosed () { 
    92             return closed; 
    93         } 
     102        public Priority greatestFired() { 
     103                if (errorFired()) 
     104                        return Priority.ERROR; 
     105                if (warnFired()) 
     106                        return Priority.WARN; 
     107                if (infoFired()) 
     108                        return Priority.INFO; 
     109                if (debugFired()) 
     110                        return Priority.DEBUG; 
     111                return null; 
     112        } 
     113 
     114        public boolean isClosed() { 
     115                return closed; 
     116        } 
    94117}