/*
    * Copyright 2008-2012 smartics, Kronseder & Reiner GmbH
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package de.smartics.util.test.io;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  
  import org.apache.commons.io.IOUtils;
  import static org.junit.Assert.fail;
  
  /**
   * Provides utility functions to help on tests dealing with serialization.
   * <p>
   * The example shows the typical usage of {@link #runSerialization(Object)}:
   * </p> {@example "Example Usage Error" final MyClass uut = new MyClass(); ...
   * SerialTestUtils.runSerialization(uut);
   * assertTrue("Serialization successful.", true);}
   * <p>
   * If the serialization is not successful, an exception is thrown. If you do not
   * want an error to be reported by JUnit you have catch the exception and fail.
   * </p> {@example "Example Usage Failure" final MyClass uut = new MyClass(); ...
   * SerialTestUtils.runSerializationQuietly(uut);
   * assertTrue("Serialization successful.", true);}
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public final class SerialTestUtils
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Utility class.
     */
    private SerialTestUtils()
    {
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Runs the serialization test and signals a fail to the JUnit runtime.
     *
     * @param <T> the type of the instance to read and write.
     * @param uut the unit under test to serialize and deserialized.
     * @return the serialized and deserialized object. Allows the client to check
     *         the internals if required.
     */
    public static <T> T runSerializationQuietly(final T uut)
    {
      try
      {
        return runSerialization(uut);
      }
      catch (final IOException e)
      {
        fail("Serialization failed.");
      }
      catch (final ClassNotFoundException e)
      {
        fail("Serialization failed since class cannot be found: "
             + e.getMessage());
      }
      return null; // never happens.
    }
  
    /**
    * Test the serialization and deserialization of the unit under test.
    *
    * @param <T> the type of the instance to read and write.
    * @param uut the unit under test to serialize and deserialized.
    * @return the serialized and deserialized object. Allows the client to check
    *         the internals if required.
    * @throws IOException if the object cannot be serialized or deserialized.
    * @throws ClassNotFoundException if the class for the deserialized object
    *           cannot be found.
    */
   public static <T> T runSerialization(final T uut) throws IOException,
     ClassNotFoundException
   {
     final byte[] data = writeObject(uut);
 
     // The following specifies the type T because of a bug in the javac
     // (including version 1.6.0_12) that prevents proper type inference.
     // * http://forums.sun.com/thread.jspa?messageID=4196171
     // * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6302954
     return SerialTestUtils.<T> readObject(data);
   }
 
   /**
    * Reads the object from the given byte array.
    *
    * @param <T> the type of the instance to read.
    * @param data the serialized object to deserialize.
    * @return the deserialized object.
    * @throws IOException if the object cannot be deserialized.
    * @throws ClassNotFoundException if the class for the deserialized object
    *           cannot be found.
    */
   @SuppressWarnings("unchecked")
   public static <T> T readObject(final byte[] data) throws IOException,
     ClassNotFoundException
   {
     final ByteArrayInputStream in = new ByteArrayInputStream(data);
     ObjectInputStream ois = null; // NOPMD resource release pattern
     try
     {
       ois = new ObjectInputStream(in);
       final T result = (T) ois.readObject();
       return result;
     }
     finally
     {
       IOUtils.closeQuietly(ois);
     }
   }
 
   /**
    * Writes the given object to an byte array.
    *
    * @param <T> the type of the instance to write.
    * @param uut the unit under test to serialize.
    * @param bufferSize the size of the in-memory buffer to write to.
    * @return the serialized object in a byte array.
    * @throws IOException if the object cannot be serialized.
    */
   public static <T> byte[] writeObject(final T uut, final int bufferSize)
     throws IOException
   {
     final ByteArrayOutputStream out = new ByteArrayOutputStream(bufferSize);
     ObjectOutputStream oos = null; // NOPMD resource release pattern
     try
     {
       oos = new ObjectOutputStream(out);
       oos.writeObject(uut);
     }
     finally
     {
       IOUtils.closeQuietly(oos);
     }
     return out.toByteArray();
   }
 
   /**
    * Writes the given object to an byte array. The size of the in-memory buffer
    * is set to 1024 bytes.
    *
    * @param <T> the type of the instance to write.
    * @param uut the unit under test to serialize.
    * @return the serialized object in a byte array.
    * @throws IOException if the object cannot be serialized.
    */
   public static <T> byte[] writeObject(final T uut) throws IOException
   {
     // The following specifies the type T because of a bug in the javac
     // (including version 1.6.0_12) that prevents proper type inference.
     // * http://forums.sun.com/thread.jspa?messageID=4196171
     // * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6302954
     return SerialTestUtils.<T> writeObject(uut, 1024);
   }
 
   // --- object basics --------------------------------------------------------
 
 }