1 /*******************************************************************************
2 * Copyright (c) 2016 École Polytechnique de Montréal
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 *******************************************************************************/
10 package org
.eclipse
.tracecompass
.statesystem
.core
.tests
.statevalue
;
12 import static org
.junit
.Assert
.assertArrayEquals
;
13 import static org
.junit
.Assert
.assertEquals
;
15 import java
.nio
.BufferOverflowException
;
16 import java
.nio
.ByteBuffer
;
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
;
25 * Test for the {@link SafeByteBufferWrapper} class
27 * @author Geneviève Bastien
29 public class SafeByteBufferWrapperTest
{
31 private final ByteBuffer fMainBuffer
;
34 * Constructor. Prepares the main buffer and safe buffer
36 public SafeByteBufferWrapperTest() {
37 fMainBuffer
= ByteBuffer
.allocate(1024);
41 * Test the {@link SafeByteBufferWrapper#put(byte)}
42 * {@link SafeByteBufferWrapper#get()} methods
45 public void testReadWriteByte() {
46 byte val
= Byte
.MAX_VALUE
;
48 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 512);
51 // Reset the buffer and read it again
53 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, 512);
54 assertEquals(val
, reader
.get());
58 * Test the {@link SafeByteBufferWrapper#put(byte[])}
59 * {@link SafeByteBufferWrapper#get(byte[])} methods
62 public void testReadWriteByteArray() {
63 byte[] val
= { 0, 2, 1, 3 };
65 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 512);
68 // Reset the buffer and read it again
70 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, 512);
71 byte[] ret
= new byte[4];
73 assertArrayEquals(val
, ret
);
77 * Test the {@link SafeByteBufferWrapper#putChar(char)}
78 * {@link SafeByteBufferWrapper#getChar()} methods
81 public void testReadWriteChar() {
84 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 512);
87 // Reset the buffer and read it again
89 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, 512);
90 assertEquals(val
, reader
.getChar());
94 * Test the {@link SafeByteBufferWrapper#putDouble(double)}
95 * {@link SafeByteBufferWrapper#getDouble()} methods
98 public void testReadWriteDouble() {
99 double val
= Double
.MAX_VALUE
;
101 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 512);
102 buffer
.putDouble(val
);
104 // Reset the buffer and read it again
106 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, 512);
107 assertEquals(val
, reader
.getDouble(), 10);
111 * Test the {@link SafeByteBufferWrapper#putFloat(float)}
112 * {@link SafeByteBufferWrapper#getFloat()} methods
115 public void testReadWriteFloat() {
116 float val
= Float
.MIN_VALUE
;
118 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 512);
119 buffer
.putFloat(val
);
121 // Reset the buffer and read it again
123 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, 512);
124 assertEquals(val
, reader
.getFloat(), 10);
128 * Test the {@link SafeByteBufferWrapper#putInt(int)}
129 * {@link SafeByteBufferWrapper#getInt()} methods
132 public void testReadWriteInt() {
133 int val
= Integer
.MAX_VALUE
;
135 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 512);
138 // Reset the buffer and read it again
140 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, 512);
141 assertEquals(val
, reader
.getInt());
145 * Test the {@link SafeByteBufferWrapper#putLong(long)}
146 * {@link SafeByteBufferWrapper#getLong()} methods
149 public void testReadWriteLong() {
150 long val
= Long
.MIN_VALUE
;
152 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 512);
155 // Reset the buffer and read it again
157 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, 512);
158 assertEquals(val
, reader
.getLong());
162 * Test the {@link SafeByteBufferWrapper#putShort(short)}
163 * {@link SafeByteBufferWrapper#getShort()} methods
166 public void testReadWriteShort() {
167 short val
= Short
.MIN_VALUE
;
169 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 512);
170 buffer
.putShort(val
);
172 // Reset the buffer and read it again
174 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, 512);
175 assertEquals(val
, reader
.getShort());
179 * Test the {@link SafeByteBufferWrapper#putString(String)}
180 * {@link SafeByteBufferWrapper#getString()} methods
183 public void testReadWriteString() {
184 String val
= "abcdefg";
186 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 512);
187 buffer
.putString(val
);
189 // Reset the buffer and read it again
191 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, 512);
192 assertEquals(val
, reader
.getString());
196 * Test adding multiple values to the buffer, inside the limits
199 public void testMultipleValues() {
202 String valStr
= "myString";
203 long valLong
= 254238908543254L;
205 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 512);
206 buffer
.putInt(valInt
);
207 buffer
.putShort(valShort
);
208 buffer
.putString(valStr
);
209 buffer
.putLong(valLong
);
211 // Reset the buffer and read it again
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());
221 * Test writing over the limit of the buffer
223 @Test(expected
= BufferOverflowException
.class)
224 public void testLimit() {
225 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, 5);
226 buffer
.putDouble(Double
.MIN_VALUE
);
230 * Test writing to main buffer after writing to safe buffer
233 public void testMainBuffer() {
234 String valString
= "defghi";
235 long valLong
= 54262542352L;
237 int bufferSize
= Integer
.BYTES
+ valString
.length() + Long
.BYTES
;
239 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, bufferSize
);
240 buffer
.putString(valString
);
241 buffer
.putLong(valLong
);
242 fMainBuffer
.putInt(valInt
);
244 // Flip the main buffer to read again
246 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, bufferSize
);
247 assertEquals(valString
, reader
.getString());
248 assertEquals(valLong
, reader
.getLong());
249 assertEquals(valInt
, fMainBuffer
.getInt());
253 * Test writing to main buffer after writing to safe buffer but not
257 public void testMainBuffer2() {
258 String valString
= "defghi";
259 long valLong
= 54262542352L;
261 int bufferSize
= Integer
.BYTES
+ valString
.length() + Long
.BYTES
+ Long
.BYTES
;
263 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, bufferSize
);
264 buffer
.putString(valString
);
265 buffer
.putLong(valLong
);
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
);
272 // Write the extra long at the end of the safe buffer
273 buffer
.putLong(valLong
);
275 // Start reading again
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());
285 * Test writing to main buffer before writing to safe buffer
288 public void testMainBuffer3() {
289 String valString
= "defghi";
290 long valLong
= 54262542352L;
292 int bufferSize
= Integer
.BYTES
+ valString
.length() + Long
.BYTES
;
294 fMainBuffer
.putLong(valLong
);
295 fMainBuffer
.putInt(valInt
);
297 ISafeByteBufferWriter buffer
= SafeByteBufferFactory
.wrapWriter(fMainBuffer
, bufferSize
);
298 buffer
.putString(valString
);
299 buffer
.putLong(valLong
);
302 assertEquals(valLong
, fMainBuffer
.getLong());
303 assertEquals(valInt
, fMainBuffer
.getInt());
305 // Flip the main buffer
306 ISafeByteBufferReader reader
= SafeByteBufferFactory
.wrapReader(fMainBuffer
, bufferSize
);
307 assertEquals(valString
, reader
.getString());
308 assertEquals(valLong
, reader
.getLong());