root/trunk/test/java/org/jcoderz/commons/LogMessageInfoTest.java

/*
 * $Id$
 *
 * Copyright 2006, The jCoderZ.org Project. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer in the documentation and/or other materials
 *      provided with the distribution.
 *    * Neither the name of the jCoderZ.org Project nor the names of
 *      its contributors may be used to endorse or promote products
 *      derived from this software without specific prior written
 *      permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.jcoderz.commons;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import junit.framework.TestCase;

/**
 * Tests the LogMessageInfo class.
 *
 * @author Michael Griffel
 */
public class LogMessageInfoTest
      extends TestCase
{
   private static final TstLogMessage CODE = TstLogMessage.TEST_MESSAGE;

   /**
    * Tests that it is possible to use the int representation of the log
    * message in a switch statement.
    */
   public void testMisc ()
   {

      switch (CODE.toInt())
      {
         case TstLogMessage.TestMessage.INT_VALUE:
               // expected
            break;
         default:
            fail("Unexpected int " + CODE.toInt() + ", expected "
                  + TstLogMessage.TestMessage.INT_VALUE);
      }
   }

   /**
    * Tests the method {@link TstLogMessage#fromString(String)}.
    */
   public void testFromString ()
   {
      assertSame("fromString method should return the same instance", CODE,
            TstLogMessage.fromString(CODE.toString()));
   }

   /**
    * Tests the method {@link TstLogMessage#fromInt(int)}.
    */
   public void testFromInt ()
   {
      assertSame("fromInt method should return the same instance", CODE,
            TstLogMessage.fromInt(CODE.toInt()));
   }

   /**
    * Tests the method {@link LogMessageInfoImpl#toInt()}.
    */
   public void testToInt ()
   {
      assertEquals("constant int representation",
            TstLogMessage.TestMessage.INT_VALUE,
            TstLogMessage.TEST_MESSAGE.toInt());
   }

   /**
    * Tests the method {@link LogMessageInfoImpl#toString()}.
    */
   public void testToString ()
   {
      assertEquals("string representation should be the message symbol",
            TstLogMessage.TEST_MESSAGE.getSymbol(),
            TstLogMessage.TEST_MESSAGE.toString());
   }

   /**
    * Tests the method {@link LogMessageInfoImpl#getSymbol()}.
    */
   public void testGetSymbol ()
   {
      assertEquals("message symbol",
            "FWK_TST_TEST_MESSAGE", TstLogMessage.TEST_MESSAGE.getSymbol());
   }

   /**
    * Tests the method {@link LogMessageInfoImpl#getLogLevel()}.
    */
   public void testGetLogLevel ()
   {
      assertEquals("default log level should be OFF",
            Level.INFO, TstLogMessage.TEST_MESSAGE.getLogLevel());
   }

   /**
    * Tests the method {@link LogMessageInfoImpl#getMessagePattern()}.
    */
   public void testGetMessagePattern ()
   {
      final String regex = ".*\\{0\\}.*\\{1,date\\}.*\\{1,time\\}.*";
      assertTrue("message pattern test",
            TstLogMessage.TEST_MESSAGE.getMessagePattern().matches(regex));
   }

   /**
    * Tests the method {@link LogMessageInfoImpl#formatMessage(Map, StringBuffer)}.
    */
   public void testFormatMessage ()
   {
      final Map parameters = new HashMap();
      parameters.put(TstLogMessage.TestMessage.PARAM_FOO,
            Collections.singletonList("param"));
      parameters.put(TstLogMessage.TestMessage.PARAM_NOW,
            Collections.singletonList(new Date()));
      System.out.println("message: "
            + TstLogMessage.TEST_MESSAGE.formatMessage(parameters, null));
   }

   /**
    * Tests the method {@link LogMessageInfoImpl#getSolution()}.
    */
   public void testGetSolution ()
   {
      assertNotNull("test solution", TstLogMessage.TEST_MESSAGE.getSolution());
   }

   /**
    * Tests the method {@link LogMessageInfoImpl#getBusinessImpact()}.
    */
   public void testGetBusinessImpact ()
   {
      assertEquals("test business impact", BusinessImpact.UNDEFINED,
            TstLogMessage.TEST_MESSAGE.getBusinessImpact());
   }

   /**
    * Tests the method {@link Object#hashCode()}.
    */
   public void testHashCode ()
   {
      assertEquals("fromString method should return the same hashCode",
            CODE.hashCode(),
            TstLogMessage.fromString(CODE.toString()).hashCode());
      assertEquals("fromInt method should return the same hashCode",
            CODE.hashCode(),
            TstLogMessage.fromInt(CODE.toInt()).hashCode());
   }

   /**
    * Tests the method readResolve().
    * @throws Exception in case of an unexpected error.
    */
   public void testSerialize ()
         throws Exception
   {
      final ByteArrayOutputStream bOut = new ByteArrayOutputStream();
      final ObjectOutputStream objOut = new ObjectOutputStream(bOut);

      objOut.writeObject(CODE);
      objOut.flush();

      final ByteArrayInputStream bIn
            = new ByteArrayInputStream(bOut.toByteArray());
      final ObjectInputStream objIn = new ObjectInputStream(bIn);

      final TstLogMessage p = (TstLogMessage) objIn.readObject();

      assertEquals("Object must be equal after serialization", p, CODE);
      assertSame("Object must be same(!) after serialization", p, CODE);
   }

   /**
    * Test the usage of the test message w/ exception wrapper.
    */
   public void testSampleError ()
   {
      final String parameter = "bar";
      final SampleError error = new SampleError(parameter);
      error.log();
      assertEquals("The parameter foo should not be modified",
            parameter,
            error.getParameter(TstLogMessage.TestMessage.PARAM_FOO).get(0));
   }

   /**
    * Tests the serializable implementation.
    * @throws Exception in case of an unexpected error.
    */
   public void testSerializable ()
         throws Exception
   {
      final ByteArrayOutputStream bOut = new ByteArrayOutputStream();
      final ObjectOutputStream objOut = new ObjectOutputStream(bOut);
      ByteArrayInputStream bIn;
      ObjectInputStream objIn;

      objOut.writeObject(TstLogMessage.TEST_MESSAGE);
      objOut.flush();
      bIn = new ByteArrayInputStream(bOut.toByteArray());
      objIn = new ObjectInputStream(bIn);
      final TstLogMessage messageRead = (TstLogMessage) objIn.readObject();

      assertSame("Values or reference changed during serialization.",
            TstLogMessage.TEST_MESSAGE, messageRead);
   }

   /**
    * Tests the if the special audit log event is generated.
    */
   public void testAuditLogEvent ()
   {
      final String dummyToString = "Dummy Audit Log Event";
      final AuditPrincipal principal = new AuditPrincipal()
         {
            private static final long serialVersionUID = 1L;

            public String toString ()
            {
               return dummyToString;
            }
         };
      final AuditLogEvent event
            = TstLogMessage.TestAuditMessage.create(principal);
      assertEquals("Expected dummy to string representation", dummyToString,
            event.getAuditPrincipal().toString());
      event.log();
   }

   /**
    * Sample exception using test log message.
    *
    * @author Michael Griffel
    */
   public static final class SampleError
         extends BaseException
      {
         static final long serialVersionUID = 1;

         /**
          * Constructor.
          * @param foo The parameter value for foo.
          */
         public SampleError (String foo)
         {
            super(TstLogMessage.TEST_MESSAGE);
            addParameter(TstLogMessage.TestMessage.PARAM_FOO, foo);
            addParameter(TstLogMessage.TestMessage.PARAM_NOW, new Date());
         }
      }

}