sjs/media
1
0
Fork 0
mirror of https://github.com/samsonjs/media.git synced 2026-04-27 15:07:40 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Improve ParsableBitArray unit tests

Browse source 
PiperOrigin-RevId: 277744735
This commit is contained in:
kimvde 2019-10-31 17:03:26 +00:00 committed by Oliver Woodman
parent 981008f76e
commit 32dcd80b4a
1 changed files with 123 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

206
library/core/src/test/java/com/google/android/exoplayer2/util/ParsableBitArrayTest.java
View file

@ -18,7 +18,7 @@ package com.google.android.exoplayer2.util;
import static com.google.common.truth.Truth.assertThat; import static com.google.common.truth.Truth.assertThat;
import androidx.test.ext.junit.runners.AndroidJUnit4; import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.Before; import com.google.android.exoplayer2.testutil.TestUtil;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
@ -26,59 +26,108 @@ import org.junit.runner.RunWith;
@RunWith(AndroidJUnit4.class) @RunWith(AndroidJUnit4.class)
public final class ParsableBitArrayTest { public final class ParsableBitArrayTest {
private static final byte[] TEST_DATA = new byte[] {0x3C, (byte) 0xD2, (byte) 0x5F, (byte) 0x01,
(byte) 0xFF, (byte) 0x14, (byte) 0x60, (byte) 0x99};
private ParsableBitArray testArray;
@Before
public void setUp() {
testArray = new ParsableBitArray(TEST_DATA);
}
@Test @Test
public void testReadAllBytes() { public void testReadAllBytes() {
byte[] bytesRead = new byte[TEST_DATA.length]; byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F);
testArray.readBytes(bytesRead, 0, TEST_DATA.length); ParsableBitArray testArray = new ParsableBitArray(testData);
assertThat(bytesRead).isEqualTo(TEST_DATA); byte[] bytesRead = new byte[testData.length];
assertThat(testArray.getPosition()).isEqualTo(TEST_DATA.length * 8);
assertThat(testArray.getBytePosition()).isEqualTo(TEST_DATA.length); testArray.readBytes(bytesRead, 0, testData.length);
assertThat(bytesRead).isEqualTo(testData);
assertThat(testArray.getPosition()).isEqualTo(testData.length * 8);
assertThat(testArray.getBytePosition()).isEqualTo(testData.length);
} }
@Test @Test
public void testReadBit() { public void testReadBitInSameByte() {
assertReadBitsToEnd(0); byte[] testData = TestUtil.createByteArray(0, 0b00110000);
ParsableBitArray testArray = new ParsableBitArray(testData);
testArray.setPosition(10);
assertThat(testArray.readBit()).isTrue();
assertThat(testArray.readBit()).isTrue();
assertThat(testArray.readBit()).isFalse();
assertThat(testArray.readBit()).isFalse();
} }
@Test @Test
public void testReadBits() { public void testReadBitInMultipleBytes() {
assertThat(testArray.readBits(5)).isEqualTo(getTestDataBits(0, 5)); byte[] testData = TestUtil.createByteArray(1, 1 << 7);
assertThat(testArray.readBits(0)).isEqualTo(getTestDataBits(5, 0)); ParsableBitArray testArray = new ParsableBitArray(testData);
assertThat(testArray.readBits(3)).isEqualTo(getTestDataBits(5, 3)); testArray.setPosition(6);
assertThat(testArray.readBits(16)).isEqualTo(getTestDataBits(8, 16));
assertThat(testArray.readBits(3)).isEqualTo(getTestDataBits(24, 3)); assertThat(testArray.readBit()).isFalse();
assertThat(testArray.readBits(18)).isEqualTo(getTestDataBits(27, 18)); assertThat(testArray.readBit()).isTrue();
assertThat(testArray.readBits(5)).isEqualTo(getTestDataBits(45, 5)); assertThat(testArray.readBit()).isTrue();
assertThat(testArray.readBits(14)).isEqualTo(getTestDataBits(50, 14)); assertThat(testArray.readBit()).isFalse();
}
@Test
public void testReadBits0Bits() {
byte[] testData = TestUtil.createByteArray(0x3C);
ParsableBitArray testArray = new ParsableBitArray(testData);
int result = testArray.readBits(0);
assertThat(result).isEqualTo(0);
}
@Test
public void testReadBitsByteAligned() {
byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F, 0x01);
ParsableBitArray testArray = new ParsableBitArray(testData);
testArray.readBits(8);
int result = testArray.readBits(18);
assertThat(result).isEqualTo(0xD25F << 2);
assertThat(testArray.getPosition()).isEqualTo(26);
}
@Test
public void testReadBitsNonByteAligned() {
byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F);
ParsableBitArray testArray = new ParsableBitArray(testData);
testArray.readBits(3);
int result = testArray.readBits(14);
assertThat(result).isEqualTo((0x3C & 0b11111) << 9 | 0xD2 << 1 | 0x5F >> 7);
assertThat(testArray.getPosition()).isEqualTo(17);
}
@Test
public void testReadBitsNegativeValue() {
byte[] testData = TestUtil.createByteArray(0xF0, 0, 0, 0);
ParsableBitArray testArray = new ParsableBitArray(testData);
int result = testArray.readBits(32);
assertThat(result).isEqualTo(0xF0000000);
} }
@Test @Test
public void testReadBitsToByteArray() { public void testReadBitsToByteArray() {
byte[] result = new byte[TEST_DATA.length]; byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F, 0x01, 0xFF, 0x14, 0x60, 0x99);
ParsableBitArray testArray = new ParsableBitArray(testData);
int numBytes = testData.length;
byte[] result = new byte[numBytes];
// Test read within byte boundaries. // Test read within byte boundaries.
testArray.readBits(result, 0, 6); testArray.readBits(result, 0, 6);
assertThat(result[0]).isEqualTo((byte) (TEST_DATA[0] & 0xFC)); assertThat(result[0]).isEqualTo((byte) (testData[0] & 0xFC));
// Test read across byte boundaries. // Test read across byte boundaries.
testArray.readBits(result, 0, 8); testArray.readBits(result, 0, 8);
assertThat(result[0]).isEqualTo( assertThat(result[0])
(byte) (((TEST_DATA[0] & 0x03) << 6) | ((TEST_DATA[1] & 0xFC) >> 2))); .isEqualTo((byte) (((testData[0] & 0x03) << 6) | ((testData[1] & 0xFC) >> 2)));
// Test reading across multiple bytes. // Test reading across multiple bytes.
testArray.readBits(result, 1, 50); testArray.readBits(result, 1, numBytes * 8 - 14);
for (int i = 1; i < 7; i++) { for (int i = 1; i < numBytes - 1; i++) {
assertThat(result[i]) assertThat(result[i])
.isEqualTo((byte) (((TEST_DATA[i] & 0x03) << 6) | ((TEST_DATA[i + 1] & 0xFC) >> 2))); .isEqualTo((byte) (((testData[i] & 0x03) << 6) | ((testData[i + 1] & 0xFC) >> 2)));
} }
assertThat(result[7]).isEqualTo((byte) ((TEST_DATA[7] & 0x03) << 6)); assertThat(result[numBytes - 1]).isEqualTo((byte) ((testData[numBytes - 1] & 0x03) << 6));
assertThat(testArray.bitsLeft()).isEqualTo(0); assertThat(testArray.bitsLeft()).isEqualTo(0);
// Test read last buffer byte across input data bytes. // Test read last buffer byte across input data bytes.
testArray.setPosition(31); testArray.setPosition(31);
@ -98,8 +147,8 @@ public final class ParsableBitArrayTest {
// Test reading a number of bits divisible by 8. // Test reading a number of bits divisible by 8.
testArray.setPosition(0); testArray.setPosition(0);
testArray.readBits(result, 0, 16); testArray.readBits(result, 0, 16);
assertThat(result[0]).isEqualTo(TEST_DATA[0]); assertThat(result[0]).isEqualTo(testData[0]);
assertThat(result[1]).isEqualTo(TEST_DATA[1]); assertThat(result[1]).isEqualTo(testData[1]);
// Test least significant bits are unmodified. // Test least significant bits are unmodified.
result[1] = (byte) 0xFF; result[1] = (byte) 0xFF;
testArray.readBits(result, 0, 9); testArray.readBits(result, 0, 9);
@ -107,64 +156,80 @@ public final class ParsableBitArrayTest {
assertThat(result[1]).isEqualTo((byte) 0x7F); assertThat(result[1]).isEqualTo((byte) 0x7F);
} }
@Test
public void testRead32BitsByteAligned() {
assertThat(testArray.readBits(32)).isEqualTo(getTestDataBits(0, 32));
assertThat(testArray.readBits(32)).isEqualTo(getTestDataBits(32, 32));
}
@Test
public void testRead32BitsNonByteAligned() {
assertThat(testArray.readBits(5)).isEqualTo(getTestDataBits(0, 5));
assertThat(testArray.readBits(32)).isEqualTo(getTestDataBits(5, 32));
}
@Test @Test
public void testSkipBytes() { public void testSkipBytes() {
byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F, 0x01);
ParsableBitArray testArray = new ParsableBitArray(testData);
testArray.skipBytes(2); testArray.skipBytes(2);
assertReadBitsToEnd(16);
assertThat(testArray.readBits(8)).isEqualTo(0x5F);
} }
@Test @Test
public void testSkipBitsByteAligned() { public void testSkipBitsByteAligned() {
byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F, 0x01);
ParsableBitArray testArray = new ParsableBitArray(testData);
testArray.skipBits(16); testArray.skipBits(16);
assertReadBitsToEnd(16);
assertThat(testArray.readBits(8)).isEqualTo(0x5F);
} }
@Test @Test
public void testSkipBitsNonByteAligned() { public void testSkipBitsNonByteAligned() {
byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F, 0x01);
ParsableBitArray testArray = new ParsableBitArray(testData);
testArray.skipBits(5); testArray.skipBits(5);
assertReadBitsToEnd(5);
assertThat(testArray.readBits(11)).isEqualTo((0x3C & 0b111) << 8 | 0xD2);
} }
@Test @Test
public void testSetPositionByteAligned() { public void testSetPositionByteAligned() {
byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F, 0x01);
ParsableBitArray testArray = new ParsableBitArray(testData);
testArray.setPosition(16); testArray.setPosition(16);
assertReadBitsToEnd(16);
assertThat(testArray.readBits(8)).isEqualTo(0x5F);
} }
@Test @Test
public void testSetPositionNonByteAligned() { public void testSetPositionNonByteAligned() {
byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F, 0x01);
ParsableBitArray testArray = new ParsableBitArray(testData);
testArray.setPosition(5); testArray.setPosition(5);
assertReadBitsToEnd(5);
assertThat(testArray.readBits(11)).isEqualTo((0x3C & 0b111) << 8 | 0xD2);
} }
@Test @Test
public void testByteAlignFromNonByteAligned() { public void testByteAlignFromNonByteAligned() {
byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F, 0x01);
ParsableBitArray testArray = new ParsableBitArray(testData);
testArray.setPosition(11); testArray.setPosition(11);
testArray.byteAlign(); testArray.byteAlign();
assertThat(testArray.getBytePosition()).isEqualTo(2); assertThat(testArray.getBytePosition()).isEqualTo(2);
assertThat(testArray.getPosition()).isEqualTo(16); assertThat(testArray.getPosition()).isEqualTo(16);
assertReadBitsToEnd(16); assertThat(testArray.readBits(8)).isEqualTo(0x5F);
} }
@Test @Test
public void testByteAlignFromByteAligned() { public void testByteAlignFromByteAligned() {
byte[] testData = TestUtil.createByteArray(0x3C, 0xD2, 0x5F, 0x01);
ParsableBitArray testArray = new ParsableBitArray(testData);
testArray.setPosition(16); testArray.setPosition(16);
testArray.byteAlign(); // Should be a no-op. testArray.byteAlign(); // Should be a no-op.
assertThat(testArray.getBytePosition()).isEqualTo(2); assertThat(testArray.getBytePosition()).isEqualTo(2);
assertThat(testArray.getPosition()).isEqualTo(16); assertThat(testArray.getPosition()).isEqualTo(16);
assertReadBitsToEnd(16); assertThat(testArray.readBits(8)).isEqualTo(0x5F);
} }
@Test @Test
@ -184,8 +249,8 @@ public final class ParsableBitArrayTest {
output.setPosition(12); output.setPosition(12);
output.putInt(0xFF, 8); output.putInt(0xFF, 8);
output.setPosition(8);
output.setPosition(8);
assertThat(output.readBits(16)).isEqualTo(0x0FF0); assertThat(output.readBits(16)).isEqualTo(0x0FF0);
} }
@ -224,8 +289,7 @@ public final class ParsableBitArrayTest {
@Test @Test
public void testNoOverwriting() { public void testNoOverwriting() {
ParsableBitArray output = ParsableBitArray output =
new ParsableBitArray( new ParsableBitArray(TestUtil.createByteArray(0xFF, 0xFF, 0xFF, 0xFF, 0xFF));
new byte[] {(byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff});
output.setPosition(1); output.setPosition(1);
output.putInt(0, 30); output.putInt(0, 30);
@ -234,28 +298,4 @@ public final class ParsableBitArrayTest {
assertThat(output.readBits(32)).isEqualTo(0x80000001); assertThat(output.readBits(32)).isEqualTo(0x80000001);
} }
private void assertReadBitsToEnd(int expectedStartPosition) {
int position = testArray.getPosition();
assertThat(position).isEqualTo(expectedStartPosition);
for (int i = position; i < TEST_DATA.length * 8; i++) {
assertThat(testArray.readBit()).isEqualTo(getTestDataBit(i));
assertThat(testArray.getPosition()).isEqualTo(i + 1);
}
}
private static int getTestDataBits(int bitPosition, int length) {
int result = 0;
for (int i = 0; i < length; i++) {
result = result << 1;
if (getTestDataBit(bitPosition++)) {
result |= 0x1;
}
}
return result;
}
private static boolean getTestDataBit(int bitPosition) {
return (TEST_DATA[bitPosition / 8] & (0x80 >>> (bitPosition % 8))) != 0;
}
} }