statesystem/org.eclipse.tracecompass.statesystem.core.tests/src/org/eclipse/tracecompass/statesystem/core/tests/statevalue/SafeByteBufferWrapperTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2016 École Polytechnique de Montréal
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *******************************************************************************/
   9
  10 package org.eclipse.tracecompass.statesystem.core.tests.statevalue;
  11
  12 import static org.junit.Assert.assertArrayEquals;
  13 import static org.junit.Assert.assertEquals;
  14
  15 import java.nio.BufferOverflowException;
  16 import java.nio.ByteBuffer;
  17
  18 import org.eclipse.tracecompass.internal.provisional.statesystem.core.statevalue.ISafeByteBufferReader;
  19 import org.eclipse.tracecompass.internal.provisional.statesystem.core.statevalue.ISafeByteBufferWriter;
  20 import org.eclipse.tracecompass.internal.provisional.statesystem.core.statevalue.SafeByteBufferFactory;
  21 import org.eclipse.tracecompass.internal.statesystem.core.statevalue.SafeByteBufferWrapper;
  22 import org.junit.Test;
  23
  24 /**
  25  * Test for the {@link SafeByteBufferWrapper} class
  26  *
  27  * @author Geneviève Bastien
  28  */
  29 public class SafeByteBufferWrapperTest {
  30
  31     private final ByteBuffer fMainBuffer;
  32
  33     /**
  34      * Constructor. Prepares the main buffer and safe buffer
  35      */
  36     public SafeByteBufferWrapperTest() {
  37         fMainBuffer = ByteBuffer.allocate(1024);
  38     }
  39
  40     /**
  41      * Test the {@link SafeByteBufferWrapper#put(byte)}
  42      * {@link SafeByteBufferWrapper#get()} methods
  43      */
  44     @Test
  45     public void testReadWriteByte() {
  46         byte val = Byte.MAX_VALUE;
  47
  48         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 512);
  49         buffer.put(val);
  50
  51         // Reset the buffer and read it again
  52         fMainBuffer.flip();
  53         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, 512);
  54         assertEquals(val, reader.get());
  55     }
  56
  57     /**
  58      * Test the {@link SafeByteBufferWrapper#put(byte[])}
  59      * {@link SafeByteBufferWrapper#get(byte[])} methods
  60      */
  61     @Test
  62     public void testReadWriteByteArray() {
  63         byte[] val = { 0, 2, 1, 3 };
  64
  65         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 512);
  66         buffer.put(val);
  67
  68         // Reset the buffer and read it again
  69         fMainBuffer.flip();
  70         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, 512);
  71         byte[] ret = new byte[4];
  72         reader.get(ret);
  73         assertArrayEquals(val, ret);
  74     }
  75
  76     /**
  77      * Test the {@link SafeByteBufferWrapper#putChar(char)}
  78      * {@link SafeByteBufferWrapper#getChar()} methods
  79      */
  80     @Test
  81     public void testReadWriteChar() {
  82         char val = 24;
  83
  84         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 512);
  85         buffer.putChar(val);
  86
  87         // Reset the buffer and read it again
  88         fMainBuffer.flip();
  89         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, 512);
  90         assertEquals(val, reader.getChar());
  91     }
  92
  93     /**
  94      * Test the {@link SafeByteBufferWrapper#putDouble(double)}
  95      * {@link SafeByteBufferWrapper#getDouble()} methods
  96      */
  97     @Test
  98     public void testReadWriteDouble() {
  99         double val = Double.MAX_VALUE;
 100
 101         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 512);
 102         buffer.putDouble(val);
 103
 104         // Reset the buffer and read it again
 105         fMainBuffer.flip();
 106         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, 512);
 107         assertEquals(val, reader.getDouble(), 10);
 108     }
 109
 110     /**
 111      * Test the {@link SafeByteBufferWrapper#putFloat(float)}
 112      * {@link SafeByteBufferWrapper#getFloat()} methods
 113      */
 114     @Test
 115     public void testReadWriteFloat() {
 116         float val = Float.MIN_VALUE;
 117
 118         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 512);
 119         buffer.putFloat(val);
 120
 121         // Reset the buffer and read it again
 122         fMainBuffer.flip();
 123         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, 512);
 124         assertEquals(val, reader.getFloat(), 10);
 125     }
 126
 127     /**
 128      * Test the {@link SafeByteBufferWrapper#putInt(int)}
 129      * {@link SafeByteBufferWrapper#getInt()} methods
 130      */
 131     @Test
 132     public void testReadWriteInt() {
 133         int val = Integer.MAX_VALUE;
 134
 135         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 512);
 136         buffer.putInt(val);
 137
 138         // Reset the buffer and read it again
 139         fMainBuffer.flip();
 140         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, 512);
 141         assertEquals(val, reader.getInt());
 142     }
 143
 144     /**
 145      * Test the {@link SafeByteBufferWrapper#putLong(long)}
 146      * {@link SafeByteBufferWrapper#getLong()} methods
 147      */
 148     @Test
 149     public void testReadWriteLong() {
 150         long val = Long.MIN_VALUE;
 151
 152         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 512);
 153         buffer.putLong(val);
 154
 155         // Reset the buffer and read it again
 156         fMainBuffer.flip();
 157         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, 512);
 158         assertEquals(val, reader.getLong());
 159     }
 160
 161     /**
 162      * Test the {@link SafeByteBufferWrapper#putShort(short)}
 163      * {@link SafeByteBufferWrapper#getShort()} methods
 164      */
 165     @Test
 166     public void testReadWriteShort() {
 167         short val = Short.MIN_VALUE;
 168
 169         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 512);
 170         buffer.putShort(val);
 171
 172         // Reset the buffer and read it again
 173         fMainBuffer.flip();
 174         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, 512);
 175         assertEquals(val, reader.getShort());
 176     }
 177
 178     /**
 179      * Test the {@link SafeByteBufferWrapper#putString(String)}
 180      * {@link SafeByteBufferWrapper#getString()} methods
 181      */
 182     @Test
 183     public void testReadWriteString() {
 184         String val = "abcdefg";
 185
 186         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 512);
 187         buffer.putString(val);
 188
 189         // Reset the buffer and read it again
 190         fMainBuffer.flip();
 191         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, 512);
 192         assertEquals(val, reader.getString());
 193     }
 194
 195     /**
 196      * Test adding multiple values to the buffer, inside the limits
 197      */
 198     @Test
 199     public void testMultipleValues() {
 200         int valInt = 98;
 201         short valShort = 34;
 202         String valStr = "myString";
 203         long valLong = 254238908543254L;
 204
 205         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 512);
 206         buffer.putInt(valInt);
 207         buffer.putShort(valShort);
 208         buffer.putString(valStr);
 209         buffer.putLong(valLong);
 210
 211         // Reset the buffer and read it again
 212         fMainBuffer.flip();
 213         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, 512);
 214         assertEquals(valInt, reader.getInt());
 215         assertEquals(valShort, reader.getShort());
 216         assertEquals(valStr, reader.getString());
 217         assertEquals(valLong, reader.getLong());
 218     }
 219
 220     /**
 221      * Test writing over the limit of the buffer
 222      */
 223     @Test(expected = BufferOverflowException.class)
 224     public void testLimit() {
 225         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, 5);
 226         buffer.putDouble(Double.MIN_VALUE);
 227     }
 228
 229     /**
 230      * Test writing to main buffer after writing to safe buffer
 231      */
 232     @Test
 233     public void testMainBuffer() {
 234         String valString = "defghi";
 235         long valLong = 54262542352L;
 236         int valInt = 2048;
 237         int bufferSize = Integer.BYTES + valString.length() + Long.BYTES;
 238
 239         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, bufferSize);
 240         buffer.putString(valString);
 241         buffer.putLong(valLong);
 242         fMainBuffer.putInt(valInt);
 243
 244         // Flip the main buffer to read again
 245         fMainBuffer.flip();
 246         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, bufferSize);
 247         assertEquals(valString, reader.getString());
 248         assertEquals(valLong, reader.getLong());
 249         assertEquals(valInt, fMainBuffer.getInt());
 250     }
 251
 252     /**
 253      * Test writing to main buffer after writing to safe buffer but not
 254      * completely
 255      */
 256     @Test
 257     public void testMainBuffer2() {
 258         String valString = "defghi";
 259         long valLong = 54262542352L;
 260         int valInt = 2048;
 261         int bufferSize = Integer.BYTES + valString.length() + Long.BYTES + Long.BYTES;
 262
 263         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, bufferSize);
 264         buffer.putString(valString);
 265         buffer.putLong(valLong);
 266
 267         // Assert the main buffer's position is after the safe buffer, even
 268         // though it is not completely written
 269         assertEquals(bufferSize, fMainBuffer.position());
 270         fMainBuffer.putInt(valInt);
 271
 272         // Write the extra long at the end of the safe buffer
 273         buffer.putLong(valLong);
 274
 275         // Start reading again
 276         fMainBuffer.flip();
 277         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, bufferSize);
 278         assertEquals(valString, reader.getString());
 279         assertEquals(valLong, reader.getLong());
 280         assertEquals(valLong, reader.getLong());
 281         assertEquals(valInt, fMainBuffer.getInt());
 282     }
 283
 284     /**
 285      * Test writing to main buffer before writing to safe buffer
 286      */
 287     @Test
 288     public void testMainBuffer3() {
 289         String valString = "defghi";
 290         long valLong = 54262542352L;
 291         int valInt = 2048;
 292         int bufferSize = Integer.BYTES + valString.length() + Long.BYTES;
 293
 294         fMainBuffer.putLong(valLong);
 295         fMainBuffer.putInt(valInt);
 296
 297         ISafeByteBufferWriter buffer = SafeByteBufferFactory.wrapWriter(fMainBuffer, bufferSize);
 298         buffer.putString(valString);
 299         buffer.putLong(valLong);
 300
 301         fMainBuffer.flip();
 302         assertEquals(valLong, fMainBuffer.getLong());
 303         assertEquals(valInt, fMainBuffer.getInt());
 304
 305         // Flip the main buffer
 306         ISafeByteBufferReader reader = SafeByteBufferFactory.wrapReader(fMainBuffer, bufferSize);
 307         assertEquals(valString, reader.getString());
 308         assertEquals(valLong, reader.getLong());
 309     }
 310
 311 }