    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.util.SerializationTestHelper;
    27  import org.apache.log4j.Priority;
    28  import org.apache.log4j.Category;
    29
    30
    31  /**
    32   * Tests LoggingEvent.
    33   *
    34   * @author Curt Arnold
    35   */
    36  public class LoggingEventTest extends TestCase {
    37    /**
    38     * Create LoggingEventTest.
    39     *
    40     * @param name test name.
    41     */
    42    public LoggingEventTest(final String name) {
    43      super(name);
    44    }
    45
    46    /**
    47     * Serialize a simple logging event and check it against
    48     * a witness.
    49     * @throws Exception if exception during test.
    50     */
    51    public void testSerializationSimple() throws Exception {
    52      Logger root = Logger.getRootLogger();
    53      LoggingEvent event =
    54        new LoggingEvent(
    55          root.getClass().getName(), root, Level.INFO, "Hello, world.", null);
    56  //    event.prepareForDeferredProcessing();
    57
    58      int[] skip = new int[] { 352, 353, 354, 355, 356 };
    59      SerializationTestHelper.assertSerializationEquals(
    60        "witness/serialization/simple.bin", event, skip, 237);
    61    }
    62
    63    /**
    64     * Serialize a logging event with an exception and check it against
    65     * a witness.
    66     * @throws Exception if exception during test.
    67     *
    68     */
    69    public void testSerializationWithException() throws Exception {
    70      Logger root = Logger.getRootLogger();
    71      Exception ex = new Exception("Don't panic");
    72      LoggingEvent event =
    73        new LoggingEvent(
    74          root.getClass().getName(), root, Level.INFO, "Hello, world.", ex);
    75  //    event.prepareForDeferredProcessing();
    76
    77      int[] skip = new int[] { 352, 353, 354, 355, 356 };
    78      SerializationTestHelper.assertSerializationEquals(
    79        "witness/serialization/exception.bin", event, skip, 237);
    80    }
    81
    82    /**
    83     * Serialize a logging event with an exception and check it against
    84     * a witness.
    85     * @throws Exception if exception during test.
    86     *
    87     */
    88    public void testSerializationWithLocation() throws Exception {
    89      Logger root = Logger.getRootLogger();
    90      LoggingEvent event =
    91        new LoggingEvent(
    92          root.getClass().getName(), root, Level.INFO, "Hello, world.", null);
    93      event.getLocationInformation();
    94  //    event.prepareForDeferredProcessing();
    95
    96      int[] skip = new int[] { 352, 353, 354, 355, 356 };
    97      SerializationTestHelper.assertSerializationEquals(
    98        "witness/serialization/location.bin", event, skip, 237);
    99    }
    100
    101   /**
    102    * Serialize a logging event with ndc.
    103    * @throws Exception if exception during test.
    104    *
    105    */
    106   public void testSerializationNDC() throws Exception {
    107     Logger root = Logger.getRootLogger();
    108     NDC.push("ndc test");
    109
    110     LoggingEvent event =
    111       new LoggingEvent(
    112         root.getClass().getName(), root, Level.INFO, "Hello, world.", null);
    113 //    event.prepareForDeferredProcessing();
    114
    115     int[] skip = new int[] { 352, 353, 354, 355, 356 };
    116     SerializationTestHelper.assertSerializationEquals(
    117       "witness/serialization/ndc.bin", event, skip, 237);
    118     }
    119
    120   /**
    121    * Serialize a logging event with mdc.
    122    * @throws Exception if exception during test.
    123    *
    124    */
    125   public void testSerializationMDC() throws Exception {
    126     Logger root = Logger.getRootLogger();
    127     MDC.put("mdckey", "mdcvalue");
    128
    129     LoggingEvent event =
    130       new LoggingEvent(
    131         root.getClass().getName(), root, Level.INFO, "Hello, world.", null);
    132 //    event.prepareForDeferredProcessing();
    133
    134     int[] skip = new int[] { 352, 353, 354, 355, 356 };
    135     SerializationTestHelper.assertSerializationEquals(
    136       "witness/serialization/mdc.bin", event, skip, 237);
    137   }
    138
    139   /**
    140    * Deserialize a simple logging event.
    141    * @throws Exception if exception during test.
    142    *
    143    */
    144   public void testDeserializationSimple() throws Exception {
    145     Object obj =
    146       SerializationTestHelper.deserializeStream(
    147         "witness/serialization/simple.bin");
    148     assertTrue(obj instanceof LoggingEvent);
    149
    150     LoggingEvent event = (LoggingEvent) obj;
    151     assertEquals("Hello, world.", event.getMessage());
    152     assertEquals(Level.INFO, event.getLevel());
    153   }
    154
    155   /**
    156    * Deserialize a logging event with an exception.
    157    * @throws Exception if exception during test.
    158    *
    159    */
    160   public void testDeserializationWithException() throws Exception {
    161     Object obj =
    162       SerializationTestHelper.deserializeStream(
    163         "witness/serialization/exception.bin");
    164     assertTrue(obj instanceof LoggingEvent);
    165
    166     LoggingEvent event = (LoggingEvent) obj;
    167     assertEquals("Hello, world.", event.getMessage());
    168     assertEquals(Level.INFO, event.getLevel());
    169   }
    170
    171   /**
    172    * Deserialize a logging event with an exception.
    173    * @throws Exception if exception during test.
    174    *
    175    */
    176   public void testDeserializationWithLocation() throws Exception {
    177     Object obj =
    178       SerializationTestHelper.deserializeStream(
    179         "witness/serialization/location.bin");
    180     assertTrue(obj instanceof LoggingEvent);
    181
    182     LoggingEvent event = (LoggingEvent) obj;
    183     assertEquals("Hello, world.", event.getMessage());
    184     assertEquals(Level.INFO, event.getLevel());
    185   }
    186
    187     /**
    188      * Tests LoggingEvent.fqnOfCategoryClass.
    189      */
    190   public void testFQNOfCategoryClass() {
    191       Category root = Logger.getRootLogger();
    192       Priority info = Level.INFO;
    193       String catName = Logger.class.toString();
    194       LoggingEvent event =
    195         new LoggingEvent(
    196           catName, root, info, "Hello, world.", null);
    197       assertEquals(catName, event.fqnOfCategoryClass);
    198   }
    199
    200     /**
    201      * Tests LoggingEvent.level.
    202      * @deprecated
    203      */
    204   public void testLevel() {
    205       Category root = Logger.getRootLogger();
    206       Priority info = Level.INFO;
    207       String catName = Logger.class.toString();
    208       LoggingEvent event =
    209         new LoggingEvent(
    210           catName, root, 0L,  info, "Hello, world.", null);
    211       Priority error = Level.ERROR;
    212       event.level = error;
    213       assertEquals(Level.ERROR, event.level);
    214   }
    215
    216     /**
    217      * Tests LoggingEvent.getLocationInfo() when no FQCN is specified.
    218      * See bug 41186.
    219      */
    220   public void testLocationInfoNoFQCN() {
    221       Category root = Logger.getRootLogger();
    222 	  Priority level = Level.INFO;
    223       LoggingEvent event =
    224         new LoggingEvent(
    225           null, root, 0L,  level, "Hello, world.", null);
    226       LocationInfo info = event.getLocationInformation();
    227 	  //
    228 	  //  log4j 1.2 returns an object, its layout doesn't check for nulls.
    229 	  //  log4j 1.3 returns a null.
    230 	  //
    231 	  assertNotNull(info);
    232 	  if (info != null) {
    233 	     assertEquals("?", info.getLineNumber());
    234 		 assertEquals("?", info.getClassName());
    235 		 assertEquals("?", info.getFileName());
    236 		 assertEquals("?", info.getMethodName());
    237 	  }
    238   }
    239
    240     /**
    241      * Message object that throws a RuntimeException on toString().
    242      * See bug 37182.
    243      */
    244     private static class BadMessage {
    245         public BadMessage() {
    246         }
    247
    248         public String toString() {
    249             throw new RuntimeException();
    250         }
    251     }
    252
    253     /**
    254      * Tests that an runtime exception or error during toString
    255      * on the message parameter does not propagate to caller.
    256      * See bug 37182.
    257      */
    258     public void testBadMessage() {
    259         Category root = Logger.getRootLogger();
    260         Priority info = Level.INFO;
    261         String catName = Logger.class.toString();
    262         BadMessage msg = new BadMessage();
    263         LoggingEvent event =
    264           new LoggingEvent(
    265             catName, root, 0L,  info, msg, null);
    266         //  would result in exception in earlier versions
    267         event.getRenderedMessage();
    268     }
    269
    270
    271 }