org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/io/BitBufferTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013 Ericsson
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     Matthew Khouzam - Initial API and implementation
  10  *******************************************************************************/
  11
  12 package org.eclipse.linuxtools.ctf.core.tests.io;
  13
  14 import static org.junit.Assert.assertEquals;
  15 import static org.junit.Assert.assertNotNull;
  16
  17 import java.nio.ByteBuffer;
  18 import java.nio.ByteOrder;
  19
  20 import org.eclipse.jdt.annotation.NonNull;
  21 import org.eclipse.linuxtools.ctf.core.event.io.BitBuffer;
  22 import org.eclipse.linuxtools.ctf.core.trace.CTFReaderException;
  23 import org.junit.Before;
  24 import org.junit.Test;
  25
  26 /**
  27  * The class <code>BitBufferTest</code> contains tests for the class
  28  * <code>{@link BitBuffer}</code>.
  29  *
  30  * @author ematkho
  31  * @version $Revision: 1.0 $
  32  */
  33 public class BitBufferTest {
  34
  35     private BitBuffer fixture;
  36
  37     /**
  38      * Perform pre-test initialization.
  39      *
  40      * @throws CTFReaderException
  41      *             An error that cannot happen (position is under 128)
  42      */
  43     @Before
  44     public void setUp() throws CTFReaderException {
  45         fixture = new BitBuffer(java.nio.ByteBuffer.allocateDirect(0));
  46         fixture.setByteOrder(ByteOrder.BIG_ENDIAN);
  47         fixture.position(1);
  48     }
  49
  50     /**
  51      * Run the BitBuffer() constructor test.
  52      */
  53     @Test
  54     public void testBitBuffer() {
  55         BitBuffer result = new BitBuffer();
  56
  57         assertNotNull(result);
  58         assertEquals(0, result.position());
  59         assertEquals(null, result.getByteBuffer());
  60     }
  61
  62     /**
  63      * Run the BitBuffer(ByteBuffer) constructor test.
  64      */
  65     @Test
  66     public void testBitBuffer_fromByteBuffer() {
  67         ByteBuffer buf = ByteBuffer.allocate(0);
  68         BitBuffer result = new BitBuffer(buf);
  69
  70         assertNotNull(result);
  71         assertEquals(0, result.position());
  72     }
  73
  74     /**
  75      * Run the boolean canRead(int) method test.
  76      */
  77     @Test
  78     public void testCanRead_1param() {
  79         int length = 1;
  80         boolean result = fixture.canRead(length);
  81
  82         assertEquals(false, result);
  83     }
  84
  85     /**
  86      * Run the void clear() method test.
  87      */
  88     @Test
  89     public void testClear() {
  90         fixture.clear();
  91     }
  92
  93     /**
  94      * Run the ByteBuffer getByteBuffer() method test.
  95      */
  96     @Test
  97     public void testGetByteBuffer() {
  98         ByteBuffer result = fixture.getByteBuffer();
  99
 100         assertNotNull(result);
 101         assertEquals("java.nio.DirectByteBuffer[pos=0 lim=0 cap=0]", result.toString());
 102         assertEquals(true, result.isDirect());
 103         assertEquals(false, result.hasArray());
 104         assertEquals(0, result.limit());
 105         assertEquals(0, result.remaining());
 106         assertEquals(0, result.position());
 107         assertEquals(0, result.capacity());
 108         assertEquals(false, result.hasRemaining());
 109         assertEquals(false, result.isReadOnly());
 110     }
 111
 112     /**
 113      * Run the ByteOrder getByteOrder() method test.
 114      */
 115     @Test
 116     public void testGetByteOrder() {
 117         ByteOrder result = fixture.getByteOrder();
 118
 119         assertNotNull(result);
 120         assertEquals("BIG_ENDIAN", result.toString());
 121     }
 122
 123     /**
 124      * Run the ByteOrder order() method test.
 125      */
 126     @Test
 127     public void testGetOrder() {
 128         ByteOrder result = fixture.getByteOrder();
 129
 130         assertNotNull(result);
 131         assertEquals("BIG_ENDIAN", result.toString());
 132     }
 133
 134     /**
 135      * Run the void order(ByteOrder) method test.
 136      */
 137     @Test
 138     public void testSetOrder() {
 139         ByteOrder order = ByteOrder.BIG_ENDIAN;
 140
 141         fixture.setByteOrder(order);
 142     }
 143
 144     /**
 145      * Run the int position() method test.
 146      */
 147     @Test
 148     public void testGetPosition() {
 149         long result = fixture.position();
 150
 151         assertEquals(1, result);
 152     }
 153
 154     /**
 155      * Run the void position(int) method test.
 156      *
 157      * @throws CTFReaderException
 158      *             out of bounds? won't happen
 159      */
 160     @Test
 161     public void testSetPosition() throws CTFReaderException {
 162         int newPosition = 1;
 163         fixture.position(newPosition);
 164     }
 165
 166     /**
 167      * Run the void setByteOrder(ByteOrder) method test.
 168      */
 169     @Test
 170     public void testSetByteOrder() {
 171         ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
 172         fixture.setByteOrder(byteOrder);
 173     }
 174
 175     /**
 176      * Test the get function
 177      */
 178     @Test
 179     public void testGetBytes() {
 180         @NonNull
 181         byte[] data = new byte[2];
 182         ByteBuffer bb = ByteBuffer.allocate(10);
 183         bb.put((byte) 0);
 184         bb.put((byte) 1);
 185         bb.put((byte) 1);
 186         bb.put((byte) 0);
 187         fixture = new BitBuffer(bb);
 188         fixture.get(data);
 189         assertEquals(0, data[0]);
 190         assertEquals(1, data[1]);
 191         fixture.get(data);
 192         assertEquals(1, data[0]);
 193         assertEquals(0, data[1]);
 194     }
 195
 196     /**
 197      * Test the get function
 198      *
 199      * @throws CTFReaderException
 200      *             won't happen but we seek in a buffer
 201      */
 202     @Test
 203     public void testGetBytesMiddle() throws CTFReaderException {
 204         @NonNull
 205         byte[] data = new byte[5];
 206         // this string has been carefully selected and tested... don't change
 207         // the string and expect the result to be the same.
 208         ByteBuffer bb = ByteBuffer.wrap(new String("hello world").getBytes());
 209         fixture = new BitBuffer(bb);
 210         fixture.position(6 * 8);
 211         fixture.get(data);
 212         String actual = new String(data);
 213         assertEquals("world", actual);
 214     }
 215 }