package org.apache.torque.generator.outlet;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  
  import static org.junit.Assert.assertArrayEquals;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertTrue;
  import static org.junit.Assert.fail;
  
  import org.apache.torque.generator.GeneratorException;
  import org.junit.Before;
  import org.junit.Test;
  
  /**
   * Component tests for OutletResult.
   *
   * @version $Id: $
   *
   */
  public class OutletResultTest
  {
      private static final String STRING_INITIAL_CONTENT = "String!\r\ncontent";
  
      private static final byte[] BYTE_ARRAY_INITIAL_CONTENT
              = new byte[] {34, -56, 126, -127 };
  
      /** System under test. */
      private OutletResult stringOutletResult;
  
      /** System under test. */
      private OutletResult byteArrayOutletResult;
  
      @Before
      public void setUp()
      {
          byteArrayOutletResult = new OutletResult(BYTE_ARRAY_INITIAL_CONTENT);
          stringOutletResult = new OutletResult(STRING_INITIAL_CONTENT);
      }
  
      /**
       * Checks that the getStringResult() method returns the correct content.
       */
      @Test
      public void testGetStringResult()
      {
          assertEquals(
                  STRING_INITIAL_CONTENT,
                  stringOutletResult.getStringResult());
          assertEquals(
                  null,
                  byteArrayOutletResult.getStringResult());
      }
  
      /**
       * Checks that the getStringResult() method returns the correct content.
       */
      @Test
      public void testGetByteArrayResult()
      {
          assertEquals(
                  null,
                  stringOutletResult.getByteArrayResult());
          assertEquals(
                  BYTE_ARRAY_INITIAL_CONTENT,
                  byteArrayOutletResult.getByteArrayResult());
      }
  
      /**
       * Checks that the isStringResult() method returns the correct content.
       */
      @Test
      public void testIsStringResult()
      {
          assertTrue(stringOutletResult.isStringResult());
          assertFalse(byteArrayOutletResult.isStringResult());
          assertTrue(new OutletResult((byte[]) null).isStringResult());
          assertTrue(new OutletResult((String) null).isStringResult());
      }
  
      /**
       * Checks that the isByteArrayResult() method returns the correct content.
      */
     @Test
     public void testIsByteArrayResult()
     {
         assertFalse(stringOutletResult.isByteArrayResult());
         assertTrue(byteArrayOutletResult.isByteArrayResult());
         assertTrue(new OutletResult((byte[]) null).isByteArrayResult());
         assertTrue(new OutletResult((String) null).isByteArrayResult());
     }
 
     /**
      * Checks that the concatenate() throws an exception if
      * OutletResults of different types are concatenated.
      */
     @Test
     public void testConcatenateWrongTypes()
     {
         try
         {
             OutletResult.concatenate(stringOutletResult, byteArrayOutletResult);
             fail("Exception expected");
         }
         catch (GeneratorException e)
         {
             assertEquals("first OutletResult to concatenate is a "
                     + "String result but a following result is a "
                     + "byte array."
                     + " All concatenated results must be "
                     + "of the same type",
                 e.getMessage());
         }
         try
         {
             OutletResult.concatenate(byteArrayOutletResult, stringOutletResult);
             fail("Exception expected");
         }
         catch (GeneratorException e)
         {
             assertEquals("first OutletResult to concatenate is a "
                     + "byte array result but a following result is a "
                     + "String result."
                     + " All concatenated results must be "
                     + "of the same type",
                 e.getMessage());
         }
     }
 
     /**
      * Checks that the concatenate() method works for normal String results.
      *
      * @throws GeneratorException
      */
     @Test
     public void testConcatenateString() throws GeneratorException
     {
         OutletResult result = OutletResult.concatenate(
                 stringOutletResult,
                 new OutletResult("bdf"),
                 new OutletResult("123"));
         assertEquals(
                 STRING_INITIAL_CONTENT + "bdf" + "123",
                 result.getStringResult());
         assertEquals(null, result.getByteArrayResult());
         assertTrue(result.isStringResult());
         assertFalse(result.isByteArrayResult());
     }
 
     /**
      * Checks that the concatenate() method works for null String results.
      *
      * @throws GeneratorException
      */
     @Test
     public void testConcatenateNullString() throws GeneratorException
     {
         OutletResult result = OutletResult.concatenate(
                 stringOutletResult,
                 new OutletResult((String) null));
         assertEquals(STRING_INITIAL_CONTENT, result.getStringResult());
     }
 
     /**
      * Checks that the concatenate() method works if we start
      * with a null string result.
      *
      * @throws GeneratorException
      */
     @Test
     public void testConcatenateStartingWithNullString()
             throws GeneratorException
     {
         OutletResult result = OutletResult.concatenate(
                 new OutletResult((String) null),
                 stringOutletResult);
         assertEquals(STRING_INITIAL_CONTENT, result.getStringResult());
     }
 
     /**
      * Checks that the concatenate() method works for normal byte array results.
      *
      * @throws GeneratorException
      */
     @Test
     public void testConcatenateByteArray() throws GeneratorException
     {
         OutletResult result = OutletResult.concatenate(
                 byteArrayOutletResult,
                 new OutletResult(new byte[] {11, -22}),
                 new OutletResult(new byte[] {1, 0}));
         assertArrayEquals(
                 new byte[] {34, -56, 126, -127, 11, -22, 1, 0},
                 result.getByteArrayResult());
         assertEquals(null, result.getStringResult());
         assertFalse(result.isStringResult());
         assertTrue(result.isByteArrayResult());
     }
 
     /**
      * Checks that the concatenate() method works for null byte array results.
      *
      * @throws GeneratorException
      */
     @Test
     public void testConcatenateNullByteArray() throws GeneratorException
     {
         OutletResult result = OutletResult.concatenate(
                 byteArrayOutletResult,
                 new OutletResult((byte[]) null));
         assertArrayEquals(
                 BYTE_ARRAY_INITIAL_CONTENT,
                 result.getByteArrayResult());
     }
 
     /**
      * Checks that the concatenate() method works if we start
      * with a null byte array result.
      *
      * @throws GeneratorException
      */
     @Test
     public void testConcatenateStartingWithNullByteArray()
             throws GeneratorException
     {
         OutletResult result = OutletResult.concatenate(
                 new OutletResult((byte[]) null),
                 byteArrayOutletResult);
         assertArrayEquals(
                 BYTE_ARRAY_INITIAL_CONTENT,
                 result.getByteArrayResult());
     }
 
     /**
      * Checks that the concatenate() method throws an exception for a null
      * input.
      *
      * @throws GeneratorException
      */
     @Test
     public void testConcatenateNullArray() throws GeneratorException
     {
         try
         {
             OutletResult.concatenate((OutletResult[]) null);
             fail("Exception expected");
         }
         catch (NullPointerException e)
         {
             assertEquals("input must not be null", e.getMessage());
         }
     }
 
     /**
      * Checks that the concatenate() method throws an exception for a null
      * input.
      *
      * @throws GeneratorException
      */
     @Test
     public void testConcatenateNullList() throws GeneratorException
     {
         try
         {
             OutletResult.concatenate((Iterable<OutletResult>) null);
             fail("Exception expected");
         }
         catch (NullPointerException e)
         {
             assertEquals("input must not be null", e.getMessage());
         }
     }
 
     /**
      * Checks that the concatenate() method throws an exception for an empty
      * input.
      *
      * @throws GeneratorException
      */
     @Test
     public void testConcatenateEmpty() throws GeneratorException
     {
         try
         {
             OutletResult.concatenate();
             fail("Exception expected");
         }
         catch (IllegalArgumentException e)
         {
             assertEquals("input must not be empty", e.getMessage());
         }
     }
 
     /**
      * Checks that the equals() method returns the correct content.
      */
     @Test
     public void testEquals()
     {
         // null
         assertFalse(
                 stringOutletResult.equals(null));
 
         // different class
         assertFalse(
                 stringOutletResult.equals("abc"));
 
         // different content class
         assertFalse(
                 stringOutletResult.equals(byteArrayOutletResult));
 
         // same object
         assertTrue(stringOutletResult.equals(stringOutletResult));
 
         // same string content
         assertTrue(
                 stringOutletResult.equals(
                         new OutletResult(STRING_INITIAL_CONTENT)));
 
         // different string content
         assertFalse(
                 stringOutletResult.equals(
                         new OutletResult("abc")));
         assertFalse(
                 stringOutletResult.equals(
                         new OutletResult((String) null)));
 
         // same byte array content
         assertTrue(
                 byteArrayOutletResult.equals(
                         new OutletResult(BYTE_ARRAY_INITIAL_CONTENT)));
 
         // different byte array content
         assertFalse(
                 byteArrayOutletResult.equals(
                         new OutletResult(new byte[] {37, 51})));
         assertFalse(
                 byteArrayOutletResult.equals(
                         new OutletResult((byte[]) null)));
     }
 
 
 }