/*
    * $HeadURL: $
    * $Date: $
    * $Revision: $
    * $Author: $
    * 
    * Copyright (c) 2007 MindTree Consulting Ltd. 
    * 
    * This file is part of Insight Remote Protocol Library.
   * 
   * Insight Remote Protocol Library is free software: you can redistribute it 
   * and/or modify it under the terms of the GNU General Public License as 
   * published by the Free Software Foundation, either version 3 of the License, 
   * or (at your option) any later version.
   * 
   * Insight Remote Protocol Library is distributed in the hope that it will be 
   * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of 
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General 
   * Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with 
   * Insight Remote Protocol Library.  If not, see <http://www.gnu.org/licenses/>.
   */
  package com.mindtree.techworks.insight.remoteprotocol.util;
  
  import java.io.UnsupportedEncodingException;
  import java.nio.charset.CharacterCodingException;
  import java.util.Arrays;
  import java.util.Random;
  
  import junit.framework.TestCase;
  
  /**
   * Tests for the {@link ByteUtils} class
   * 
   * @see ByteUtils
   * 
   * @author <a href="mailto:bindul_bhowmik@mindtree.com">Bindul Bhowmik</a>
   * @version $Revision: $ $Date: $
   */
  public class ByteUtilsTest extends TestCase {
  	
  	/**
  	 * The test values for shorts
  	 */
  	private byte[] inputShortBytes = null;
  	
  	/**
  	 * Test values for shorts
  	 */
  	private short[] inputShort = null;
  	
  	/**
  	 * Test values for integers
  	 */
  	private byte[] inputIntBytes = null;
  	
  	/**
  	 * Input values for integers
  	 */
  	private int[] inputInt = null;
  	
  	/**
  	 * Input values for strings
  	 */
  	private String[] inputStrings = null;
  
  	/* (non-Javadoc)
  	 * @see junit.framework.TestCase#setUp()
  	 */
  	protected void setUp() throws Exception {
  		// The input bytes are organized as
  		// 	- -32,768
  		//  - -1
  		//  - 0
  		//  - 10
  		//  - 32,767
  		//  - 1004
  		inputShortBytes = new byte[]{-128, 0, 
  				-1, -1, 
  				Byte.parseByte("00000000", 2), Byte.parseByte("00000000", 2), 
  				Byte.parseByte("00000000", 2), Byte.parseByte("00001010", 2),
  				Byte.parseByte("01111111", 2), (byte)Short.parseShort("11111111", 2),
  				Byte.parseByte("00000011", 2), (byte)Short.parseShort("11101100", 2)};
  		
  		inputShort = new short[] {-32768, -1, 0 , 10, 32767, 1004};
  		
  		// The input bytes are organized as
  		// 	- -2 147 483 648
  		//  - -1
  		//  - 0
  		//  - 10
  		//  - 2147483647
  		//  - 1004
  		inputIntBytes = new byte[]{-128, 0, 0, 0,
  				-1, -1, -1, -1,
  				Byte.parseByte("00000000", 2), Byte.parseByte("00000000", 2), Byte.parseByte("00000000", 2), Byte.parseByte("00000000", 2), 
  				Byte.parseByte("00000000", 2), Byte.parseByte("00000000", 2), Byte.parseByte("00000000", 2), Byte.parseByte("00001010", 2),
  				Byte.parseByte("01111111", 2), (byte)Short.parseShort("11111111", 2), (byte)Short.parseShort("11111111", 2), (byte)Short.parseShort("11111111", 2),
 				Byte.parseByte("00000000", 2), Byte.parseByte("00000000", 2),  Byte.parseByte("00000011", 2), (byte)Short.parseShort("11101100", 2)};
 		
 		inputInt = new int[] {-2147483648, -1, 0, 10, 2147483647, 1004};
 		
 		// Input Strings
 		inputStrings = new String[] {
 				"Lorem ipsum dolor sit amet, consectetuer adipiscing elit.",
 				"Donec non sem non velit hendrerit faucibus.",
 				"Phasellus convallis laoreet ligula.",
 				"Sed volutpat auctor turpis",
 				"Phasellus pharetra varius diam.",
 				"Fusce a erat vel lorem luctus rutrum.",
 				"Proin vitae dolor vel enim mattis lobortis.",
 				"Donec eu turpis at mi elementum accumsan."};
 	}
 
 	/* (non-Javadoc)
 	 * @see junit.framework.TestCase#tearDown()
 	 */
 	protected void tearDown() throws Exception {
 		super.tearDown();
 	}
 
 	/**
 	 * Test method for {@link com.mindtree.techworks.insight.remoteprotocol.util.ByteUtils#readShortFromByteArray(byte[], int)}.
 	 */
 	public void testReadShortFromByteArray() {
 		
 		int offSet = 0;
 		for (int i = 0; i < inputShort.length; i++) {
 			short testNum = inputShort[i];
 			assertEquals(testNum, ByteUtils.readShortFromByteArray(inputShortBytes, offSet));
 			offSet += 2;
 		}
 	}
 
 	/**
 	 * Test method for {@link com.mindtree.techworks.insight.remoteprotocol.util.ByteUtils#readIntFromByteArray(byte[], int)}.
 	 */
 	public void testReadIntFromByteArray() {
 		
 		int offset = 0;
 		for (int i = 0; i < inputInt.length; i++) {
 			int testNum = inputInt[i];
 			assertEquals(testNum, ByteUtils.readIntFromByteArray(inputIntBytes, offset));
 			offset += 4;
 		}
 	}
 
 	/**
 	 * Test method for {@link com.mindtree.techworks.insight.remoteprotocol.util.ByteUtils#getByteArrayForShort(short)}.
 	 */
 	public void testGetByteArrayForShort() {
 		
 		int offset = 0;
 		for (int i = 0; i < inputShort.length; i++) {
 			short testNum = inputShort[i];
 			assertTrue(Arrays.equals(ByteUtils.getByteArrayForShort(testNum), subArray(inputShortBytes, offset, 2)));
 			offset += 2;
 		}
 	}
 
 	/**
 	 * Test method for {@link com.mindtree.techworks.insight.remoteprotocol.util.ByteUtils#putBytesInArrayForShort(short, byte[], int)}.
 	 */
 	public void testPutBytesInArrayForShort() {
 		int offset = 0;
 		Random random = new Random();
 		int bufferLength = 20;
 		for (int i = 0; i < inputShort.length; i++) {
 			short testNum = inputShort[i];
 			// Get a position between 0 and 17 to fill in the buffer
 			int pos = random.nextInt(bufferLength - 2);
 			byte[] outputBuf = new byte[bufferLength];
 			random.nextBytes(outputBuf);
 			byte[] testBuf = new byte[bufferLength];
 			System.arraycopy(outputBuf, 0, testBuf, 0, testBuf.length);
 			System.arraycopy(inputShortBytes, offset, testBuf, pos, 2);
 			
 			ByteUtils.putBytesInArrayForShort(testNum, outputBuf, pos);
 			assertTrue(Arrays.equals(outputBuf, testBuf));
 			offset += 2;
 		}
 	}
 
 	/**
 	 * Test method for {@link com.mindtree.techworks.insight.remoteprotocol.util.ByteUtils#getByteArrayForInt(int)}.
 	 */
 	public void testGetByteArrayForInt() {
 		
 		int offset = 0;
 		for (int i = 0; i < inputInt.length; i++) {
 			int testNum = inputInt[i];
 			assertTrue(Arrays.equals(ByteUtils.getByteArrayForInt(testNum), subArray(inputIntBytes, offset, 4)));
 			offset += 4;
 		}
 	}
 
 	/**
 	 * Test method for {@link com.mindtree.techworks.insight.remoteprotocol.util.ByteUtils#putBytesInArrayForInt(int, byte[], int)}.
 	 */
 	public void testPutBytesInArrayForInt() {
 		int offset = 0;
 		Random random = new Random();
 		int bufferLength = 20;
 		for (int i = 0; i < inputInt.length; i++) {
 			int testNum = inputInt[i];
 			// Get a position between 0 and 15 to fill in the buffer
 			int pos = random.nextInt(bufferLength - 4);
 			byte[] outputBuf = new byte[bufferLength];
 			random.nextBytes(outputBuf);
 			byte[] testBuf = new byte[bufferLength];
 			System.arraycopy(outputBuf, 0, testBuf, 0, testBuf.length);
 			System.arraycopy(inputIntBytes, offset, testBuf, pos, 4);
 			
 			ByteUtils.putBytesInArrayForInt(testNum, outputBuf, pos);
 			assertTrue(Arrays.equals(outputBuf, testBuf));
 			offset += 4;
 		}
 	}
 
 	/**
 	 * Test method for {@link com.mindtree.techworks.insight.remoteprotocol.util.ByteUtils#getByteArrayForString(java.lang.String)}.
 	 */
 	public void testGetByteArrayForString() {
 		for (int i = 0; i < inputStrings.length; i++) {
 			String inputString = inputStrings[i];
 			try {
 				assertTrue(Arrays.equals(ByteUtils.getByteArrayForString(inputString), inputString.getBytes("UTF-8")));
 			} catch (CharacterCodingException e) {
 				fail("Exception encoding characters");
 			} catch (UnsupportedEncodingException e) {
 				fail("Platform does not support encoding, test will fail");
 			}
 		}
 	}
 
 	/**
 	 * Test method for {@link com.mindtree.techworks.insight.remoteprotocol.util.ByteUtils#getByteArrayForCharacterArray(char[])}.
 	 */
 	public void testGetByteArrayForCharacterArray() {
 		for (int i = 0; i < inputStrings.length; i++) {
 			String inputString = inputStrings[i];
 			try {
 				assertTrue(Arrays.equals(ByteUtils.getByteArrayForCharacterArray(inputString.toCharArray()), inputString.getBytes("UTF-8")));
 			} catch (CharacterCodingException e) {
 				fail("Exception encoding characters");
 			} catch (UnsupportedEncodingException e) {
 				fail("Platform does not support encoding, test will fail");
 			}
 		}
 	}
 	
 	/**
 	 * Test method for {@link com.mindtree.techworks.insight.remoteprotocol.util.ByteUtils#readStringFromByteArray(byte[], int, int)}
 	 */
 	public void testReadStringFromByteArray () {
 		for (int i = 0; i < inputStrings.length; i++) {
 			String inputString = inputStrings[i];
 			byte[] encodedString = null;
 			try {
 				encodedString = inputString.getBytes("UTF-8");
 			} catch (UnsupportedEncodingException e) {
 				fail("Platform does not support encoding, test will fail");
 			}
 			try {
 				assertEquals(inputString, ByteUtils.readStringFromByteArray(encodedString, 0, encodedString.length));
 			} catch (CharacterCodingException e) {
 				fail("Exception encoding characters");
 			}
 		}
 	}
 
 	/**
 	 * Creates an array of bytes using the range provided
 	 * @param inputArray The array to subset
 	 * @param offset The start point of the range
 	 * @param length The length of the range
 	 * @return The subset of the array
 	 */
 	private byte[] subArray (byte[] inputArray, int offset, int length) {
 		if (offset < 0) {
 			throw new ArrayIndexOutOfBoundsException("Offset cannot be less than 0");
 		}
 		if (offset > (inputArray.length + 1) || (offset + length) > (inputArray.length)) {
 			throw new ArrayIndexOutOfBoundsException("Range should be withing the input array");
 		}
 		
 		byte[] returnArray = new byte[length];
 		System.arraycopy(inputArray, offset, returnArray, 0, length);
 		
 		return returnArray;
 	}
 }