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