Commit | Line | Data |
---|---|---|
4bd7f2db | 1 | /******************************************************************************* |
0f231de2 | 2 | * Copyright (c) 2013, 2014 Ericsson |
4bd7f2db AM |
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: | |
3cde463e AM |
9 | * Alexandre Montplaisir - Extracted from BitBufferTest, cleanup |
10 | * Matthew Khouzam - Additional tests | |
4bd7f2db AM |
11 | *******************************************************************************/ |
12 | ||
866e5b51 FC |
13 | package org.eclipse.linuxtools.ctf.core.tests.io; |
14 | ||
15 | import static org.junit.Assert.assertEquals; | |
16 | ||
17 | import java.nio.ByteBuffer; | |
18 | import java.nio.ByteOrder; | |
19 | ||
486efb2e | 20 | import org.eclipse.linuxtools.ctf.core.event.io.BitBuffer; |
db8e8f7d | 21 | import org.eclipse.linuxtools.ctf.core.trace.CTFReaderException; |
866e5b51 FC |
22 | import org.junit.Before; |
23 | import org.junit.Test; | |
24 | ||
25 | /** | |
3cde463e AM |
26 | * Part of the {@link BitBuffer} tests which test the methods to read/write |
27 | * integers. These are separated from the main file because the fixture is | |
28 | * different. | |
8b8e48ed | 29 | * |
2b50c5ac | 30 | * @author Alexandre Montplaisir |
866e5b51 FC |
31 | */ |
32 | public class BitBufferIntTest { | |
33 | ||
34 | private BitBuffer fixture; | |
35 | ||
866e5b51 FC |
36 | /** |
37 | * Perform pre-test initialization. | |
4c67e724 MK |
38 | * |
39 | * @throws CTFReaderException | |
40 | * Out of bounds, won't happen | |
866e5b51 FC |
41 | */ |
42 | @Before | |
4c67e724 | 43 | public void setUp() throws CTFReaderException { |
aefc5c83 MK |
44 | ByteBuffer allocateDirect = ByteBuffer.allocateDirect(128); |
45 | if (allocateDirect == null) { | |
46 | throw new IllegalStateException("Failed to allocate memory"); | |
47 | } | |
48 | fixture = new BitBuffer(allocateDirect); | |
866e5b51 | 49 | fixture.setByteOrder(ByteOrder.BIG_ENDIAN); |
733c614c | 50 | fixture = createBuffer(); |
866e5b51 FC |
51 | } |
52 | ||
733c614c MK |
53 | private static BitBuffer createBuffer() throws CTFReaderException { |
54 | return createBuffer(16); | |
866e5b51 FC |
55 | } |
56 | ||
733c614c | 57 | private static BitBuffer createBuffer(int j) throws CTFReaderException { |
4c67e724 | 58 | final byte[] bytes = new byte[j]; |
866e5b51 FC |
59 | for (int i = 0; i < j; i++) { |
60 | bytes[i] = (byte) (i % 0xff); | |
61 | } | |
aefc5c83 MK |
62 | ByteBuffer wrap = ByteBuffer.wrap(bytes); |
63 | if (wrap == null) { | |
64 | throw new IllegalStateException("Failed to allocate memory"); | |
65 | } | |
66 | BitBuffer fixture = new BitBuffer(wrap); | |
866e5b51 | 67 | fixture.position(1); |
733c614c | 68 | return fixture; |
866e5b51 FC |
69 | } |
70 | ||
71 | /** | |
3cde463e | 72 | * Test {@link BitBuffer#getInt} with a basic value |
db8e8f7d AM |
73 | * |
74 | * @throws CTFReaderException | |
75 | * Not expected | |
866e5b51 FC |
76 | */ |
77 | @Test | |
db8e8f7d | 78 | public void testGetInt_base() throws CTFReaderException { |
866e5b51 FC |
79 | int result = fixture.getInt(); |
80 | assertEquals(0x020406, result); | |
81 | } | |
82 | ||
83 | /** | |
3cde463e | 84 | * Test {@link BitBuffer#getInt} with explicit seek at pos 0. |
db8e8f7d AM |
85 | * |
86 | * @throws CTFReaderException | |
87 | * Not expected | |
866e5b51 FC |
88 | */ |
89 | @Test | |
db8e8f7d | 90 | public void testGetInt_pos0() throws CTFReaderException { |
866e5b51 FC |
91 | fixture.position(0); |
92 | int result = fixture.getInt(); | |
93 | assertEquals(0x010203, result); | |
94 | } | |
95 | ||
96 | /** | |
3cde463e | 97 | * Test {@link BitBuffer#get} with seek at pos 1. |
db8e8f7d AM |
98 | * |
99 | * @throws CTFReaderException | |
100 | * Not expected | |
866e5b51 FC |
101 | */ |
102 | @Test | |
db8e8f7d | 103 | public void testGetInt_pos1() throws CTFReaderException { |
866e5b51 | 104 | fixture.position(1); |
866e5b51 | 105 | |
3cde463e | 106 | long result = fixture.get(1, true); |
866e5b51 FC |
107 | assertEquals(0, result); |
108 | } | |
109 | ||
110 | /** | |
3cde463e | 111 | * Test {@link BitBuffer#get} with seek at pos 2. |
db8e8f7d AM |
112 | * |
113 | * @throws CTFReaderException | |
114 | * Not expected | |
866e5b51 FC |
115 | */ |
116 | @Test | |
db8e8f7d | 117 | public void testGetInt_pos2() throws CTFReaderException { |
866e5b51 | 118 | fixture.position(2); |
866e5b51 | 119 | |
3cde463e | 120 | long result = fixture.get(0, true); |
866e5b51 FC |
121 | assertEquals(0, result); |
122 | } | |
123 | ||
866e5b51 | 124 | /** |
3cde463e | 125 | * Test {@link BitBuffer#get} with explicit little-endian reading. |
db8e8f7d AM |
126 | * |
127 | * @throws CTFReaderException | |
128 | * Not expected | |
866e5b51 FC |
129 | */ |
130 | @Test | |
3cde463e | 131 | public void testGetInt_le2() throws CTFReaderException { |
733c614c | 132 | BitBuffer leFixture = createBuffer(128); |
3cde463e | 133 | leFixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); |
3cde463e | 134 | leFixture.position(0); |
3cde463e AM |
135 | long result = leFixture.get(24, false); |
136 | assertEquals(0x020100, result); | |
866e5b51 FC |
137 | } |
138 | ||
139 | /** | |
3cde463e AM |
140 | * Test {@link BitBuffer#get} with explicit little-endian reading, with an |
141 | * offset. | |
db8e8f7d AM |
142 | * |
143 | * @throws CTFReaderException | |
144 | * Not expected | |
866e5b51 FC |
145 | */ |
146 | @Test | |
db8e8f7d | 147 | public void testGetInt_le1() throws CTFReaderException { |
733c614c | 148 | BitBuffer leFixture = createBuffer(128); |
3cde463e | 149 | leFixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); |
3cde463e | 150 | leFixture.position(1); |
3cde463e | 151 | long result = leFixture.get(24, false); |
733c614c | 152 | assertEquals(0x810080, result); /* 0x020100 down-shifted */ |
866e5b51 FC |
153 | } |
154 | ||
866e5b51 | 155 | /** |
3cde463e AM |
156 | * Test {@link BitBuffer#get} with a 32-bit out-of-bounds read. Should throw |
157 | * an exception. | |
db8e8f7d AM |
158 | * |
159 | * @throws CTFReaderException | |
160 | * Expected | |
866e5b51 | 161 | */ |
db8e8f7d AM |
162 | @Test(expected = CTFReaderException.class) |
163 | public void testGetInt_invalid() throws CTFReaderException { | |
733c614c | 164 | BitBuffer smallFixture = createBuffer(2); |
3cde463e | 165 | smallFixture.setByteOrder(ByteOrder.BIG_ENDIAN); |
733c614c | 166 | |
3cde463e AM |
167 | smallFixture.position(10); |
168 | ||
169 | /* This will attempt to read past the buffer's end. */ | |
170 | smallFixture.get(32, true); | |
866e5b51 FC |
171 | } |
172 | ||
173 | /** | |
3cde463e AM |
174 | * Test {@link BitBuffer#get} with a 64-bit out-of-bounds read. Should throw |
175 | * an exception. | |
db8e8f7d AM |
176 | * |
177 | * @throws CTFReaderException | |
178 | * Expected | |
866e5b51 | 179 | */ |
db8e8f7d AM |
180 | @Test(expected = CTFReaderException.class) |
181 | public void testGetInt_invalid2() throws CTFReaderException { | |
733c614c | 182 | BitBuffer smallFixture = createBuffer(2); |
3cde463e | 183 | smallFixture.setByteOrder(ByteOrder.BIG_ENDIAN); |
733c614c | 184 | |
3cde463e | 185 | smallFixture.position(1); |
866e5b51 | 186 | |
3cde463e AM |
187 | /* This will attempt to read past the buffer's end. */ |
188 | smallFixture.get(64, true); | |
2b50c5ac MK |
189 | } |
190 | ||
191 | /** | |
3cde463e | 192 | * Test {@link BitBuffer#getLong}. |
2b50c5ac MK |
193 | * |
194 | * @throws CTFReaderException | |
195 | * error | |
196 | */ | |
197 | @Test | |
198 | public void testGetLong_pos0() throws CTFReaderException { | |
199 | fixture.position(0); | |
200 | long result = fixture.getLong(); | |
201 | assertEquals(0x01020304050607L, result); | |
202 | } | |
203 | ||
204 | /** | |
3cde463e | 205 | * Test {@link BitBuffer#getLong} with an offset of 7. |
2b50c5ac MK |
206 | * |
207 | * @throws CTFReaderException | |
208 | * error | |
209 | */ | |
210 | @Test | |
211 | public void testGetLong_pos7() throws CTFReaderException { | |
212 | fixture.position(7); | |
213 | long result = fixture.getLong(); | |
214 | assertEquals(0x81018202830384L, result); | |
215 | } | |
216 | ||
217 | /** | |
3cde463e | 218 | * Test {@link BitBuffer#getLong} with an offset of 8. |
2b50c5ac MK |
219 | * |
220 | * @throws CTFReaderException | |
221 | * error | |
222 | */ | |
223 | @Test | |
224 | public void testGetLong_pos8() throws CTFReaderException { | |
225 | fixture.position(8); | |
226 | long result = fixture.getLong(); | |
3cde463e | 227 | assertEquals(0x0102030405060708L, result); |
2b50c5ac MK |
228 | } |
229 | ||
230 | /** | |
3cde463e | 231 | * Test {@link BitBuffer#getLong} with a little-endian buffer. |
2b50c5ac MK |
232 | * |
233 | * @throws CTFReaderException | |
234 | * error | |
235 | */ | |
236 | @Test | |
237 | public void testGetLong_pos0LE() throws CTFReaderException { | |
238 | fixture.position(0); | |
239 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
240 | long result = fixture.getLong(); | |
3cde463e | 241 | assertEquals(0x0706050403020100L, result); |
2b50c5ac MK |
242 | } |
243 | ||
244 | /** | |
3cde463e | 245 | * Test {@link BitBuffer#getLong} with a little-endian buffer at pos 7. |
2b50c5ac MK |
246 | * |
247 | * @throws CTFReaderException | |
248 | * error | |
249 | */ | |
250 | @Test | |
251 | public void testGetLong_pos7LE() throws CTFReaderException { | |
252 | fixture.position(7); | |
253 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
254 | long result = fixture.getLong(); | |
3cde463e | 255 | assertEquals(0x100e0c0a08060402L, result); |
2b50c5ac MK |
256 | } |
257 | ||
258 | /** | |
3cde463e | 259 | * Test {@link BitBuffer#getLong} with a little-endian buffer at pos 8. |
2b50c5ac MK |
260 | * |
261 | * @throws CTFReaderException | |
262 | * error | |
263 | */ | |
264 | @Test | |
265 | public void testGetLong_pos8LE() throws CTFReaderException { | |
266 | fixture.position(8); | |
267 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
268 | long result = fixture.getLong(); | |
3cde463e | 269 | assertEquals(0x0807060504030201L, result); |
2b50c5ac MK |
270 | } |
271 | ||
272 | /** | |
3cde463e | 273 | * Test {@link BitBuffer#get} for >32 bits in length. |
2b50c5ac MK |
274 | * |
275 | * @throws CTFReaderException | |
276 | * error | |
277 | */ | |
278 | @Test | |
279 | public void testGet35_pos0BE() throws CTFReaderException { | |
280 | fixture.position(0); | |
281 | long result = fixture.get(35, false); | |
3cde463e | 282 | assertEquals(0x081018L, result); |
2b50c5ac MK |
283 | } |
284 | ||
285 | /** | |
3cde463e | 286 | * Test {@link BitBuffer#get} for >32 bits in length at an offset position. |
2b50c5ac MK |
287 | * |
288 | * @throws CTFReaderException | |
289 | * error | |
290 | */ | |
291 | @Test | |
292 | public void testGet35_pos8BE() throws CTFReaderException { | |
293 | fixture.position(8); | |
294 | long result = fixture.get(35, false); | |
3cde463e | 295 | assertEquals(0x08101820L, result); |
2b50c5ac MK |
296 | } |
297 | ||
298 | /** | |
3cde463e | 299 | * Test {@link BitBuffer#get} for >32 bits in length in little-endian. |
2b50c5ac MK |
300 | * |
301 | * @throws CTFReaderException | |
302 | * error | |
303 | */ | |
304 | @Test | |
305 | public void testGet35_pos0LE() throws CTFReaderException { | |
306 | fixture.position(0); | |
307 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
308 | long result = fixture.get(35, false); | |
3cde463e | 309 | assertEquals(0x0403020100L, result); |
2b50c5ac MK |
310 | } |
311 | ||
312 | /** | |
3cde463e AM |
313 | * Test {@link BitBuffer#get} for >32 bits in length, in little-endian, at |
314 | * position 7. | |
2b50c5ac MK |
315 | * |
316 | * @throws CTFReaderException | |
317 | * error | |
318 | */ | |
319 | @Test | |
320 | public void testGetLong35_pos7LE() throws CTFReaderException { | |
321 | fixture.position(7); | |
322 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
323 | long result = fixture.get(35, false); | |
3cde463e | 324 | assertEquals(0x0208060402L, result); |
2b50c5ac MK |
325 | } |
326 | ||
327 | /** | |
3cde463e AM |
328 | * Test {@link BitBuffer#get} for >32 bits in length, in little-endian, at |
329 | * position 8. | |
2b50c5ac MK |
330 | * |
331 | * @throws CTFReaderException | |
332 | * error | |
333 | */ | |
334 | @Test | |
335 | public void testGetLong35_pos8LE() throws CTFReaderException { | |
336 | fixture.position(8); | |
337 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
338 | long result = fixture.get(35, false); | |
3cde463e | 339 | assertEquals(0x0504030201L, result); |
2b50c5ac MK |
340 | } |
341 | ||
342 | /** | |
3cde463e AM |
343 | * Test {@link BitBuffer#get} for >32 bits in length, in little-endian, for |
344 | * a signed value. | |
2b50c5ac MK |
345 | * |
346 | * @throws CTFReaderException | |
347 | * error | |
348 | */ | |
349 | @Test | |
350 | public void testGetLong35s_pos0LE() throws CTFReaderException { | |
351 | fixture.position(0); | |
352 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
353 | long result = fixture.get(35, true); | |
3cde463e | 354 | assertEquals(0xfffffffc03020100L, result); |
2b50c5ac MK |
355 | } |
356 | ||
357 | /** | |
3cde463e AM |
358 | * Test {@link BitBuffer#get} for >32 bits in length, in little-endian, for |
359 | * a signed value, at position 7. | |
2b50c5ac MK |
360 | * |
361 | * @throws CTFReaderException | |
362 | * error | |
363 | */ | |
364 | @Test | |
365 | public void testGetLong35s_pos7LE() throws CTFReaderException { | |
366 | fixture.position(7); | |
367 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
368 | long result = fixture.get(35, true); | |
3cde463e | 369 | assertEquals(0x0208060402L, result); |
2b50c5ac MK |
370 | } |
371 | ||
372 | /** | |
3cde463e AM |
373 | * Test {@link BitBuffer#get} for >32 bits in length, in little-endian, for |
374 | * a signed value, at position 8. | |
2b50c5ac MK |
375 | * |
376 | * @throws CTFReaderException | |
377 | * error | |
378 | */ | |
379 | @Test | |
380 | public void testGetLong35s_pos8LE() throws CTFReaderException { | |
381 | fixture.position(8); | |
382 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
383 | long result = fixture.get(35, true); | |
3cde463e | 384 | assertEquals(0xfffffffd04030201L, result); |
2b50c5ac MK |
385 | } |
386 | ||
387 | /** | |
3cde463e | 388 | * Test reading negative values as signed values. |
2b50c5ac MK |
389 | * |
390 | * @throws CTFReaderException | |
391 | * error | |
392 | */ | |
393 | @Test | |
394 | public void testGetSigned() throws CTFReaderException { | |
395 | fixture.position(0); | |
396 | fixture.putInt(-1); | |
397 | fixture.putInt(-1); | |
398 | fixture.position(0); | |
399 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
3cde463e | 400 | |
2b50c5ac | 401 | long result = fixture.get(32, true); |
3cde463e | 402 | assertEquals(-1L, result); |
2b50c5ac MK |
403 | } |
404 | ||
405 | /** | |
3cde463e | 406 | * Test reading negative values as unsigned values. |
2b50c5ac MK |
407 | * |
408 | * @throws CTFReaderException | |
409 | * error | |
410 | */ | |
411 | @Test | |
412 | public void testGetUnsigned() throws CTFReaderException { | |
413 | fixture.position(0); | |
414 | fixture.putInt(-1); | |
415 | fixture.putInt(-1); | |
416 | fixture.position(0); | |
417 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
3cde463e | 418 | |
2b50c5ac MK |
419 | long result = fixture.get(32, false); |
420 | assertEquals(0xFFFFFFFFL, result); | |
421 | } | |
422 | ||
2b50c5ac | 423 | /** |
3cde463e | 424 | * Test reading 24 bits of a 32-bit negative value as a signed value. |
2b50c5ac MK |
425 | * |
426 | * @throws CTFReaderException | |
427 | * error | |
428 | */ | |
429 | @Test | |
430 | public void testGet24Signed() throws CTFReaderException { | |
431 | fixture.position(0); | |
432 | fixture.putInt(-1); | |
433 | fixture.putInt(-1); | |
434 | fixture.position(0); | |
435 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
3cde463e | 436 | |
2b50c5ac MK |
437 | long result = fixture.get(24, true); |
438 | assertEquals(-1L, result); | |
439 | } | |
440 | ||
441 | /** | |
3cde463e | 442 | * Test reading 24 bits of a 32-bit negative value as an unsigned value. |
2b50c5ac MK |
443 | * |
444 | * @throws CTFReaderException | |
445 | * error | |
446 | */ | |
447 | @Test | |
448 | public void testGet24Unsigned() throws CTFReaderException { | |
449 | fixture.position(0); | |
450 | fixture.putInt(-1); | |
451 | fixture.putInt(-1); | |
452 | fixture.position(0); | |
453 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
3cde463e | 454 | |
2b50c5ac MK |
455 | long result = fixture.get(24, false); |
456 | assertEquals(0xFFFFFFL, result); | |
866e5b51 FC |
457 | } |
458 | ||
459 | /** | |
3cde463e | 460 | * Test {@link BitBuffer#putInt(int)} |
db8e8f7d AM |
461 | * |
462 | * @throws CTFReaderException | |
463 | * Not expected | |
866e5b51 FC |
464 | */ |
465 | @Test | |
db8e8f7d | 466 | public void testPutInt() throws CTFReaderException { |
866e5b51 | 467 | fixture.position(1); |
3cde463e | 468 | fixture.putInt(1); |
866e5b51 FC |
469 | } |
470 | ||
471 | /** | |
3cde463e | 472 | * Test {@link BitBuffer#putInt(int, int)} |
db8e8f7d AM |
473 | * |
474 | * @throws CTFReaderException | |
475 | * Not expected | |
866e5b51 FC |
476 | */ |
477 | @Test | |
3cde463e | 478 | public void testPutInt_length1() throws CTFReaderException { |
866e5b51 | 479 | fixture.position(1); |
3cde463e | 480 | fixture.putInt(1, 1); |
866e5b51 FC |
481 | } |
482 | ||
483 | /** | |
3cde463e | 484 | * Test {@link BitBuffer#putInt(int, int)} with length = 0. |
db8e8f7d AM |
485 | * |
486 | * @throws CTFReaderException | |
487 | * Not expected | |
866e5b51 FC |
488 | */ |
489 | @Test | |
db8e8f7d | 490 | public void testPutInt_length0() throws CTFReaderException { |
866e5b51 | 491 | fixture.position(1); |
3cde463e | 492 | fixture.putInt(0, 1); |
866e5b51 FC |
493 | } |
494 | ||
0f231de2 MK |
495 | /** |
496 | * Test {@link BitBuffer#putInt(int)} Little endian | |
497 | * | |
498 | * @throws CTFReaderException | |
499 | * Not expected | |
500 | */ | |
501 | @Test | |
502 | public void testPutIntLe() throws CTFReaderException { | |
503 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
504 | fixture.position(1); | |
505 | fixture.putInt(1); | |
506 | } | |
507 | ||
508 | /** | |
509 | * Test {@link BitBuffer#putInt(int, int)} Little endian | |
510 | * | |
511 | * @throws CTFReaderException | |
512 | * Not expected | |
513 | */ | |
514 | @Test | |
515 | public void testPutIntLe_length1() throws CTFReaderException { | |
516 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
517 | fixture.position(1); | |
518 | fixture.putInt(1, 1); | |
519 | } | |
520 | ||
521 | /** | |
522 | * Test {@link BitBuffer#putInt(int, int)} with length = 0. Little endian | |
523 | * | |
524 | * @throws CTFReaderException | |
525 | * Not expected | |
526 | */ | |
527 | @Test | |
528 | public void testPutIntLe_length0() throws CTFReaderException { | |
529 | fixture.setByteOrder(ByteOrder.LITTLE_ENDIAN); | |
530 | fixture.position(1); | |
531 | fixture.putInt(0, 1); | |
532 | } | |
533 | ||
866e5b51 | 534 | /** |
3cde463e | 535 | * Test writing and reading a value defined in hex format. |
db8e8f7d AM |
536 | * |
537 | * @throws CTFReaderException | |
538 | * Not expected | |
866e5b51 FC |
539 | */ |
540 | @Test | |
db8e8f7d | 541 | public void testPutInt_hex() throws CTFReaderException { |
8b8e48ed | 542 | final int value = 0x010203; |
866e5b51 | 543 | |
8b8e48ed MK |
544 | for (int i = 0; i <= 32; i++) { |
545 | fixture.position(i); | |
546 | fixture.putInt(value); | |
547 | ||
548 | fixture.position(i); | |
3cde463e | 549 | int read = fixture.getInt(); |
8b8e48ed MK |
550 | |
551 | assertEquals(value, read); | |
552 | } | |
866e5b51 FC |
553 | } |
554 | ||
555 | /** | |
3cde463e AM |
556 | * Test {@link BitBuffer#putInt} with an out-of-bounds length. An exception |
557 | * should be thrown. | |
db8e8f7d AM |
558 | * |
559 | * @throws CTFReaderException | |
560 | * Expected | |
866e5b51 | 561 | */ |
db8e8f7d AM |
562 | @Test(expected = CTFReaderException.class) |
563 | public void testPutInt_invalid() throws CTFReaderException { | |
866e5b51 | 564 | BitBuffer fixture2; |
733c614c | 565 | fixture2 = createBuffer(4); |
866e5b51 | 566 | fixture2.setByteOrder(ByteOrder.BIG_ENDIAN); |
866e5b51 FC |
567 | fixture2.position(1); |
568 | ||
3cde463e AM |
569 | /* This will try writing past the buffer's end */ |
570 | fixture2.putInt(32, 1); | |
866e5b51 FC |
571 | } |
572 | } |