View Javadoc

    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *      http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   */
    17
    18  package org.apache.log4j.spi;
    19
    20  import junit.framework.TestCase;
    21
    22  import org.apache.log4j.Level;
    23  import org.apache.log4j.Logger;
    24  import org.apache.log4j.MDC;
    25  import org.apache.log4j.NDC;
    26  import org.apache.log4j.spi.LocationInfo;
    27  import org.apache.log4j.util.SerializationTestHelper;
    28  import org.apache.log4j.Priority;
    29  import org.apache.log4j.Category;
    30
    31
    32  /***
    33   * Tests LoggingEvent.
    34   *
    35   * @author Curt Arnold
    36   */
    37  public class LoggingEventTest extends TestCase {
    38    /***
    39     * Create LoggingEventTest.
    40     *
    41     * @param name test name.
    42     */
    43    public LoggingEventTest(final String name) {
    44      super(name);
    45    }
    46
    47    /***
    48     * Serialize a simple logging event and check it against
    49     * a witness.
    50     * @throws Exception if exception during test.
    51     */
    52    public void testSerializationSimple() throws Exception {
    53      Logger root = Logger.getRootLogger();
    54      LoggingEvent event =
    55        new LoggingEvent(
    56          root.getClass().getName(), root, Level.INFO, "Hello, world.", null);
    57  //    event.prepareForDeferredProcessing();
    58
    59      int[] skip = new int[] { 352, 353, 354, 355, 356 };
    60      SerializationTestHelper.assertSerializationEquals(
    61        "witness/serialization/simple.bin", event, skip, 237);
    62    }
    63
    64    /***
    65     * Serialize a logging event with an exception and check it against
    66     * a witness.
    67     * @throws Exception if exception during test.
    68     *
    69     */
    70    public void testSerializationWithException() throws Exception {
    71      Logger root = Logger.getRootLogger();
    72      Exception ex = new Exception("Don't panic");
    73      LoggingEvent event =
    74        new LoggingEvent(
    75          root.getClass().getName(), root, Level.INFO, "Hello, world.", ex);
    76  //    event.prepareForDeferredProcessing();
    77
    78      int[] skip = new int[] { 352, 353, 354, 355, 356 };
    79      SerializationTestHelper.assertSerializationEquals(
    80        "witness/serialization/exception.bin", event, skip, 237);
    81    }
    82
    83    /***
    84     * Serialize a logging event with an exception and check it against
    85     * a witness.
    86     * @throws Exception if exception during test.
    87     *
    88     */
    89    public void testSerializationWithLocation() throws Exception {
    90      Logger root = Logger.getRootLogger();
    91      LoggingEvent event =
    92        new LoggingEvent(
    93          root.getClass().getName(), root, Level.INFO, "Hello, world.", null);
    94      LocationInfo info = event.getLocationInformation();
    95  //    event.prepareForDeferredProcessing();
    96
    97      int[] skip = new int[] { 352, 353, 354, 355, 356 };
    98      SerializationTestHelper.assertSerializationEquals(
    99        "witness/serialization/location.bin", event, skip, 237);
    100   }
    101
    102   /***
    103    * Serialize a logging event with ndc.
    104    * @throws Exception if exception during test.
    105    *
    106    */
    107   public void testSerializationNDC() throws Exception {
    108     Logger root = Logger.getRootLogger();
    109     NDC.push("ndc test");
    110
    111     LoggingEvent event =
    112       new LoggingEvent(
    113         root.getClass().getName(), root, Level.INFO, "Hello, world.", null);
    114 //    event.prepareForDeferredProcessing();
    115
    116     int[] skip = new int[] { 352, 353, 354, 355, 356 };
    117     SerializationTestHelper.assertSerializationEquals(
    118       "witness/serialization/ndc.bin", event, skip, 237);
    119     }
    120
    121   /***
    122    * Serialize a logging event with mdc.
    123    * @throws Exception if exception during test.
    124    *
    125    */
    126   public void testSerializationMDC() throws Exception {
    127     Logger root = Logger.getRootLogger();
    128     MDC.put("mdckey", "mdcvalue");
    129
    130     LoggingEvent event =
    131       new LoggingEvent(
    132         root.getClass().getName(), root, Level.INFO, "Hello, world.", null);
    133 //    event.prepareForDeferredProcessing();
    134
    135     int[] skip = new int[] { 352, 353, 354, 355, 356 };
    136     SerializationTestHelper.assertSerializationEquals(
    137       "witness/serialization/mdc.bin", event, skip, 237);
    138   }
    139
    140   /***
    141    * Deserialize a simple logging event.
    142    * @throws Exception if exception during test.
    143    *
    144    */
    145   public void testDeserializationSimple() throws Exception {
    146     Object obj =
    147       SerializationTestHelper.deserializeStream(
    148         "witness/serialization/simple.bin");
    149     assertTrue(obj instanceof LoggingEvent);
    150
    151     LoggingEvent event = (LoggingEvent) obj;
    152     assertEquals("Hello, world.", event.getMessage());
    153     assertEquals(Level.INFO, event.getLevel());
    154   }
    155
    156   /***
    157    * Deserialize a logging event with an exception.
    158    * @throws Exception if exception during test.
    159    *
    160    */
    161   public void testDeserializationWithException() throws Exception {
    162     Object obj =
    163       SerializationTestHelper.deserializeStream(
    164         "witness/serialization/exception.bin");
    165     assertTrue(obj instanceof LoggingEvent);
    166
    167     LoggingEvent event = (LoggingEvent) obj;
    168     assertEquals("Hello, world.", event.getMessage());
    169     assertEquals(Level.INFO, event.getLevel());
    170   }
    171
    172   /***
    173    * Deserialize a logging event with an exception.
    174    * @throws Exception if exception during test.
    175    *
    176    */
    177   public void testDeserializationWithLocation() throws Exception {
    178     Object obj =
    179       SerializationTestHelper.deserializeStream(
    180         "witness/serialization/location.bin");
    181     assertTrue(obj instanceof LoggingEvent);
    182
    183     LoggingEvent event = (LoggingEvent) obj;
    184     assertEquals("Hello, world.", event.getMessage());
    185     assertEquals(Level.INFO, event.getLevel());
    186   }
    187
    188     /***
    189      * Tests LoggingEvent.fqnOfCategoryClass.
    190      */
    191   public void testFQNOfCategoryClass() {
    192       Category root = Logger.getRootLogger();
    193       Priority info = Level.INFO;
    194       String catName = Logger.class.toString();
    195       LoggingEvent event =
    196         new LoggingEvent(
    197           catName, root, info, "Hello, world.", null);
    198       assertEquals(catName, event.fqnOfCategoryClass);
    199   }
    200
    201     /***
    202      * Tests LoggingEvent.level.
    203      * @deprecated
    204      */
    205   public void testLevel() {
    206       Category root = Logger.getRootLogger();
    207       Priority info = Level.INFO;
    208       String catName = Logger.class.toString();
    209       LoggingEvent event =
    210         new LoggingEvent(
    211           catName, root, 0L,  info, "Hello, world.", null);
    212       Priority error = Level.ERROR;
    213       event.level = error;
    214       assertEquals(Level.ERROR, event.level);
    215   }
    216
    217     /***
    218      * Tests LoggingEvent.getLocationInfo() when no FQCN is specified.
    219      * See bug 41186.
    220      */
    221   public void testLocationInfoNoFQCN() {
    222       Category root = Logger.getRootLogger();
    223 	  Priority level = Level.INFO;
    224       LoggingEvent event =
    225         new LoggingEvent(
    226           null, root, 0L,  level, "Hello, world.", null);
    227       LocationInfo info = event.getLocationInformation();
    228 	  //
    229 	  //  log4j 1.2 returns an object, its layout doesn't check for nulls.
    230 	  //  log4j 1.3 returns a null.
    231 	  //
    232 	  assertNotNull(info);
    233 	  if (info != null) {
    234 	     assertEquals("?", info.getLineNumber());
    235 		 assertEquals("?", info.getClassName());
    236 		 assertEquals("?", info.getFileName());
    237 		 assertEquals("?", info.getMethodName());
    238 	  }
    239   }
    240
    241
    242 }