loliball/media
1
0
Fork 0
mirror of https://github.com/androidx/media.git synced 2025-04-30 06:46:50 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Statically import charset constants in ParsableByteArrayTest

Browse Source 
This makes charset-heavy tests easier to read (and I'm going to add some
more in a follow-up change).

Also switch to Truth's `isEmpty()` assertion as prompted by a lint
check.

PiperOrigin-RevId: 732925878
This commit is contained in:
ibaker 2025-03-03 08:04:37 -08:00 committed by Copybara-Service
parent 1e4a10651a
commit da8df3fb81
1 changed files with 100 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
libraries/common/src/test/java/androidx/media3/common/util/ParsableByteArrayTest.java
View File

@ -18,13 +18,17 @@ package androidx.media3.common.util;
import static androidx.media3.test.utils.TestUtil.createByteArray; import static androidx.media3.test.utils.TestUtil.createByteArray;
import static com.google.common.truth.Truth.assertThat; import static com.google.common.truth.Truth.assertThat;
import static java.nio.charset.Charset.forName; import static java.nio.charset.Charset.forName;
import static java.nio.charset.StandardCharsets.US_ASCII;
import static java.nio.charset.StandardCharsets.UTF_16;
import static java.nio.charset.StandardCharsets.UTF_16BE;
import static java.nio.charset.StandardCharsets.UTF_16LE;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertThrows;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
import androidx.test.ext.junit.runners.AndroidJUnit4; import androidx.test.ext.junit.runners.AndroidJUnit4;
import com.google.common.primitives.Bytes; import com.google.common.primitives.Bytes;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.Arrays; import java.util.Arrays;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
@ -488,7 +492,7 @@ public final class ParsableByteArrayTest {
assertThat(parser.getPosition()).isEqualTo(4); assertThat(parser.getPosition()).isEqualTo(4);
assertThat(parser.readNullTerminatedString(3)).isEqualTo("bar"); assertThat(parser.readNullTerminatedString(3)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(7); assertThat(parser.getPosition()).isEqualTo(7);
assertThat(parser.readNullTerminatedString(1)).isEqualTo(""); assertThat(parser.readNullTerminatedString(1)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(8); assertThat(parser.getPosition()).isEqualTo(8);
assertThat(parser.readNullTerminatedString()).isNull(); assertThat(parser.readNullTerminatedString()).isNull();
} }
@ -599,69 +603,69 @@ public final class ParsableByteArrayTest {
@Test @Test
public void readSingleLineWithoutEndingTrail_ascii() { public void readSingleLineWithoutEndingTrail_ascii() {
byte[] bytes = "foo".getBytes(StandardCharsets.US_ASCII); byte[] bytes = "foo".getBytes(US_ASCII);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo("foo"); assertThat(parser.readLine(US_ASCII)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(3); assertThat(parser.getPosition()).isEqualTo(3);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isNull(); assertThat(parser.readLine(US_ASCII)).isNull();
} }
@Test @Test
public void readSingleLineWithEndingLf_ascii() { public void readSingleLineWithEndingLf_ascii() {
byte[] bytes = "foo\n".getBytes(StandardCharsets.US_ASCII); byte[] bytes = "foo\n".getBytes(US_ASCII);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo("foo"); assertThat(parser.readLine(US_ASCII)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(4); assertThat(parser.getPosition()).isEqualTo(4);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isNull(); assertThat(parser.readLine(US_ASCII)).isNull();
} }
@Test @Test
public void readTwoLinesWithCrFollowedByLf_ascii() { public void readTwoLinesWithCrFollowedByLf_ascii() {
byte[] bytes = "foo\r\nbar".getBytes(StandardCharsets.US_ASCII); byte[] bytes = "foo\r\nbar".getBytes(US_ASCII);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo("foo"); assertThat(parser.readLine(US_ASCII)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(5); assertThat(parser.getPosition()).isEqualTo(5);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo("bar"); assertThat(parser.readLine(US_ASCII)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(8); assertThat(parser.getPosition()).isEqualTo(8);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isNull(); assertThat(parser.readLine(US_ASCII)).isNull();
} }
@Test @Test
public void readThreeLinesWithEmptyLine_ascii() { public void readThreeLinesWithEmptyLine_ascii() {
byte[] bytes = "foo\r\n\rbar".getBytes(StandardCharsets.US_ASCII); byte[] bytes = "foo\r\n\rbar".getBytes(US_ASCII);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo("foo"); assertThat(parser.readLine(US_ASCII)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(5); assertThat(parser.getPosition()).isEqualTo(5);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo(""); assertThat(parser.readLine(US_ASCII)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(6); assertThat(parser.getPosition()).isEqualTo(6);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo("bar"); assertThat(parser.readLine(US_ASCII)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(9); assertThat(parser.getPosition()).isEqualTo(9);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isNull(); assertThat(parser.readLine(US_ASCII)).isNull();
} }
@Test @Test
public void readFourLinesWithLfFollowedByCr_ascii() { public void readFourLinesWithLfFollowedByCr_ascii() {
byte[] bytes = "foo\n\r\rbar\r\n".getBytes(StandardCharsets.US_ASCII); byte[] bytes = "foo\n\r\rbar\r\n".getBytes(US_ASCII);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo("foo"); assertThat(parser.readLine(US_ASCII)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(4); assertThat(parser.getPosition()).isEqualTo(4);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo(""); assertThat(parser.readLine(US_ASCII)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(5); assertThat(parser.getPosition()).isEqualTo(5);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo(""); assertThat(parser.readLine(US_ASCII)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(6); assertThat(parser.getPosition()).isEqualTo(6);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isEqualTo("bar"); assertThat(parser.readLine(US_ASCII)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(11); assertThat(parser.getPosition()).isEqualTo(11);
assertThat(parser.readLine(StandardCharsets.US_ASCII)).isNull(); assertThat(parser.readLine(US_ASCII)).isNull();
} }
@Test @Test
public void readSingleLineWithoutEndingTrail_utf8() { public void readSingleLineWithoutEndingTrail_utf8() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8); byte[] bytes = "foo".getBytes(UTF_8);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine()).isEqualTo("foo"); assertThat(parser.readLine()).isEqualTo("foo");
@ -671,7 +675,7 @@ public final class ParsableByteArrayTest {
@Test @Test
public void readSingleLineWithEndingLf_utf8() { public void readSingleLineWithEndingLf_utf8() {
byte[] bytes = "foo\n".getBytes(StandardCharsets.UTF_8); byte[] bytes = "foo\n".getBytes(UTF_8);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine()).isEqualTo("foo"); assertThat(parser.readLine()).isEqualTo("foo");
@ -681,7 +685,7 @@ public final class ParsableByteArrayTest {
@Test @Test
public void readTwoLinesWithCr_utf8() { public void readTwoLinesWithCr_utf8() {
byte[] bytes = "foo\rbar".getBytes(StandardCharsets.UTF_8); byte[] bytes = "foo\rbar".getBytes(UTF_8);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine()).isEqualTo("foo"); assertThat(parser.readLine()).isEqualTo("foo");
@ -694,7 +698,7 @@ public final class ParsableByteArrayTest {
// https://github.com/androidx/media/issues/2167 // https://github.com/androidx/media/issues/2167
@Test @Test
public void readTwoLinesWithCrAndWideChar_utf8() { public void readTwoLinesWithCrAndWideChar_utf8() {
byte[] bytes = "foo\r\uD83D\uDE1B".getBytes(StandardCharsets.UTF_8); byte[] bytes = "foo\r\uD83D\uDE1B".getBytes(UTF_8);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine()).isEqualTo("foo"); assertThat(parser.readLine()).isEqualTo("foo");
@ -706,7 +710,7 @@ public final class ParsableByteArrayTest {
@Test @Test
public void readTwoLinesWithCrFollowedByLf_utf8() { public void readTwoLinesWithCrFollowedByLf_utf8() {
byte[] bytes = "foo\r\nbar".getBytes(StandardCharsets.UTF_8); byte[] bytes = "foo\r\nbar".getBytes(UTF_8);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine()).isEqualTo("foo"); assertThat(parser.readLine()).isEqualTo("foo");
@ -718,14 +722,12 @@ public final class ParsableByteArrayTest {
@Test @Test
public void readThreeLinesWithEmptyLineAndLeadingBom_utf8() { public void readThreeLinesWithEmptyLineAndLeadingBom_utf8() {
byte[] bytes = byte[] bytes = Bytes.concat(createByteArray(0xEF, 0xBB, 0xBF), "foo\r\n\rbar".getBytes(UTF_8));
Bytes.concat(
createByteArray(0xEF, 0xBB, 0xBF), "foo\r\n\rbar".getBytes(StandardCharsets.UTF_8));
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine()).isEqualTo("foo"); assertThat(parser.readLine()).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(8); assertThat(parser.getPosition()).isEqualTo(8);
assertThat(parser.readLine()).isEqualTo(""); assertThat(parser.readLine()).isEmpty();
assertThat(parser.getPosition()).isEqualTo(9); assertThat(parser.getPosition()).isEqualTo(9);
assertThat(parser.readLine()).isEqualTo("bar"); assertThat(parser.readLine()).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(12); assertThat(parser.getPosition()).isEqualTo(12);
@ -734,14 +736,14 @@ public final class ParsableByteArrayTest {
@Test @Test
public void readFourLinesWithLfFollowedByCr_utf8() { public void readFourLinesWithLfFollowedByCr_utf8() {
byte[] bytes = "foo\n\r\rbar\r\n".getBytes(StandardCharsets.UTF_8); byte[] bytes = "foo\n\r\rbar\r\n".getBytes(UTF_8);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine()).isEqualTo("foo"); assertThat(parser.readLine()).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(4); assertThat(parser.getPosition()).isEqualTo(4);
assertThat(parser.readLine()).isEqualTo(""); assertThat(parser.readLine()).isEmpty();
assertThat(parser.getPosition()).isEqualTo(5); assertThat(parser.getPosition()).isEqualTo(5);
assertThat(parser.readLine()).isEqualTo(""); assertThat(parser.readLine()).isEmpty();
assertThat(parser.getPosition()).isEqualTo(6); assertThat(parser.getPosition()).isEqualTo(6);
assertThat(parser.readLine()).isEqualTo("bar"); assertThat(parser.readLine()).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(11); assertThat(parser.getPosition()).isEqualTo(11);
@ -752,199 +754,195 @@ public final class ParsableByteArrayTest {
public void readSingleLineWithoutEndingTrail_utf16() { public void readSingleLineWithoutEndingTrail_utf16() {
// Use UTF_16BE because we don't want the leading BOM that's added by getBytes(UTF_16). We // Use UTF_16BE because we don't want the leading BOM that's added by getBytes(UTF_16). We
// explicitly test with a BOM elsewhere. // explicitly test with a BOM elsewhere.
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_16BE); byte[] bytes = "foo".getBytes(UTF_16BE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(6); assertThat(parser.getPosition()).isEqualTo(6);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isNull(); assertThat(parser.readLine(UTF_16)).isNull();
} }
@Test @Test
public void readSingleLineWithEndingLf_utf16() { public void readSingleLineWithEndingLf_utf16() {
// Use UTF_16BE because we don't want the leading BOM that's added by getBytes(UTF_16). We // Use UTF_16BE because we don't want the leading BOM that's added by getBytes(UTF_16). We
// explicitly test with a BOM elsewhere. // explicitly test with a BOM elsewhere.
byte[] bytes = "foo\n".getBytes(StandardCharsets.UTF_16BE); byte[] bytes = "foo\n".getBytes(UTF_16BE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(8); assertThat(parser.getPosition()).isEqualTo(8);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isNull(); assertThat(parser.readLine(UTF_16)).isNull();
} }
@Test @Test
public void readTwoLinesWithCrFollowedByLf_utf16() { public void readTwoLinesWithCrFollowedByLf_utf16() {
// Use UTF_16BE because we don't want the leading BOM that's added by getBytes(UTF_16). We // Use UTF_16BE because we don't want the leading BOM that's added by getBytes(UTF_16). We
// explicitly test with a BOM elsewhere. // explicitly test with a BOM elsewhere.
byte[] bytes = "foo\r\nbar".getBytes(StandardCharsets.UTF_16BE); byte[] bytes = "foo\r\nbar".getBytes(UTF_16BE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(10); assertThat(parser.getPosition()).isEqualTo(10);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo("bar"); assertThat(parser.readLine(UTF_16)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(16); assertThat(parser.getPosition()).isEqualTo(16);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isNull(); assertThat(parser.readLine(UTF_16)).isNull();
} }
@Test @Test
public void readThreeLinesWithEmptyLineAndLeadingBom_utf16() { public void readThreeLinesWithEmptyLineAndLeadingBom_utf16() {
// getBytes(UTF_16) always adds the leading BOM. // getBytes(UTF_16) always adds the leading BOM.
byte[] bytes = "foo\r\n\rbar".getBytes(StandardCharsets.UTF_16); byte[] bytes = "foo\r\n\rbar".getBytes(UTF_16);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(12); assertThat(parser.getPosition()).isEqualTo(12);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo(""); assertThat(parser.readLine(UTF_16)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(14); assertThat(parser.getPosition()).isEqualTo(14);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo("bar"); assertThat(parser.readLine(UTF_16)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(20); assertThat(parser.getPosition()).isEqualTo(20);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isNull(); assertThat(parser.readLine(UTF_16)).isNull();
} }
@Test @Test
public void readFourLinesWithLfFollowedByCr_utf16() { public void readFourLinesWithLfFollowedByCr_utf16() {
// Use UTF_16BE because we don't want the leading BOM that's added by getBytes(UTF_16). We // Use UTF_16BE because we don't want the leading BOM that's added by getBytes(UTF_16). We
// explicitly test with a BOM elsewhere. // explicitly test with a BOM elsewhere.
byte[] bytes = "foo\n\r\rbar\r\n".getBytes(StandardCharsets.UTF_16BE); byte[] bytes = "foo\n\r\rbar\r\n".getBytes(UTF_16BE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(8); assertThat(parser.getPosition()).isEqualTo(8);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo(""); assertThat(parser.readLine(UTF_16)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(10); assertThat(parser.getPosition()).isEqualTo(10);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo(""); assertThat(parser.readLine(UTF_16)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(12); assertThat(parser.getPosition()).isEqualTo(12);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isEqualTo("bar"); assertThat(parser.readLine(UTF_16)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(22); assertThat(parser.getPosition()).isEqualTo(22);
assertThat(parser.readLine(StandardCharsets.UTF_16)).isNull(); assertThat(parser.readLine(UTF_16)).isNull();
} }
@Test @Test
public void readSingleLineWithoutEndingTrail_utf16be() { public void readSingleLineWithoutEndingTrail_utf16be() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_16BE); byte[] bytes = "foo".getBytes(UTF_16BE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16BE)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(6); assertThat(parser.getPosition()).isEqualTo(6);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isNull(); assertThat(parser.readLine(UTF_16BE)).isNull();
} }
@Test @Test
public void readSingleLineWithEndingLf_utf16be() { public void readSingleLineWithEndingLf_utf16be() {
byte[] bytes = "foo\n".getBytes(StandardCharsets.UTF_16BE); byte[] bytes = "foo\n".getBytes(UTF_16BE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16BE)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(8); assertThat(parser.getPosition()).isEqualTo(8);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isNull(); assertThat(parser.readLine(UTF_16BE)).isNull();
} }
@Test @Test
public void readTwoLinesWithCrFollowedByLf_utf16be() { public void readTwoLinesWithCrFollowedByLf_utf16be() {
byte[] bytes = "foo\r\nbar".getBytes(StandardCharsets.UTF_16BE); byte[] bytes = "foo\r\nbar".getBytes(UTF_16BE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16BE)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(10); assertThat(parser.getPosition()).isEqualTo(10);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo("bar"); assertThat(parser.readLine(UTF_16BE)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(16); assertThat(parser.getPosition()).isEqualTo(16);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isNull(); assertThat(parser.readLine(UTF_16BE)).isNull();
} }
@Test @Test
public void readThreeLinesWithEmptyLineAndLeadingBom_utf16be() { public void readThreeLinesWithEmptyLineAndLeadingBom_utf16be() {
byte[] bytes = byte[] bytes = Bytes.concat(createByteArray(0xFE, 0xFF), "foo\r\n\rbar".getBytes(UTF_16BE));
Bytes.concat(
createByteArray(0xFE, 0xFF), "foo\r\n\rbar".getBytes(StandardCharsets.UTF_16BE));
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16BE)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(12); assertThat(parser.getPosition()).isEqualTo(12);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo(""); assertThat(parser.readLine(UTF_16BE)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(14); assertThat(parser.getPosition()).isEqualTo(14);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo("bar"); assertThat(parser.readLine(UTF_16BE)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(20); assertThat(parser.getPosition()).isEqualTo(20);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isNull(); assertThat(parser.readLine(UTF_16BE)).isNull();
} }
@Test @Test
public void readFourLinesWithLfFollowedByCr_utf16be() { public void readFourLinesWithLfFollowedByCr_utf16be() {
byte[] bytes = "foo\n\r\rbar\r\n".getBytes(StandardCharsets.UTF_16BE); byte[] bytes = "foo\n\r\rbar\r\n".getBytes(UTF_16BE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16BE)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(8); assertThat(parser.getPosition()).isEqualTo(8);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo(""); assertThat(parser.readLine(UTF_16BE)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(10); assertThat(parser.getPosition()).isEqualTo(10);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo(""); assertThat(parser.readLine(UTF_16BE)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(12); assertThat(parser.getPosition()).isEqualTo(12);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isEqualTo("bar"); assertThat(parser.readLine(UTF_16BE)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(22); assertThat(parser.getPosition()).isEqualTo(22);
assertThat(parser.readLine(StandardCharsets.UTF_16BE)).isNull(); assertThat(parser.readLine(UTF_16BE)).isNull();
} }
@Test @Test
public void readSingleLineWithoutEndingTrail_utf16le() { public void readSingleLineWithoutEndingTrail_utf16le() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_16LE); byte[] bytes = "foo".getBytes(UTF_16LE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16LE)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(6); assertThat(parser.getPosition()).isEqualTo(6);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isNull(); assertThat(parser.readLine(UTF_16LE)).isNull();
} }
@Test @Test
public void readSingleLineWithEndingLf_utf16le() { public void readSingleLineWithEndingLf_utf16le() {
byte[] bytes = "foo\n".getBytes(StandardCharsets.UTF_16LE); byte[] bytes = "foo\n".getBytes(UTF_16LE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16LE)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(8); assertThat(parser.getPosition()).isEqualTo(8);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isNull(); assertThat(parser.readLine(UTF_16LE)).isNull();
} }
@Test @Test
public void readTwoLinesWithCrFollowedByLf_utf16le() { public void readTwoLinesWithCrFollowedByLf_utf16le() {
byte[] bytes = "foo\r\nbar".getBytes(StandardCharsets.UTF_16LE); byte[] bytes = "foo\r\nbar".getBytes(UTF_16LE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16LE)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(10); assertThat(parser.getPosition()).isEqualTo(10);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo("bar"); assertThat(parser.readLine(UTF_16LE)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(16); assertThat(parser.getPosition()).isEqualTo(16);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isNull(); assertThat(parser.readLine(UTF_16LE)).isNull();
} }
@Test @Test
public void readThreeLinesWithEmptyLineAndLeadingBom_utf16le() { public void readThreeLinesWithEmptyLineAndLeadingBom_utf16le() {
byte[] bytes = byte[] bytes = Bytes.concat(createByteArray(0xFF, 0xFE), "foo\r\n\rbar".getBytes(UTF_16LE));
Bytes.concat(
createByteArray(0xFF, 0xFE), "foo\r\n\rbar".getBytes(StandardCharsets.UTF_16LE));
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16LE)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(12); assertThat(parser.getPosition()).isEqualTo(12);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo(""); assertThat(parser.readLine(UTF_16LE)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(14); assertThat(parser.getPosition()).isEqualTo(14);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo("bar"); assertThat(parser.readLine(UTF_16LE)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(20); assertThat(parser.getPosition()).isEqualTo(20);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isNull(); assertThat(parser.readLine(UTF_16LE)).isNull();
} }
@Test @Test
public void readFourLinesWithLfFollowedByCr_utf16le() { public void readFourLinesWithLfFollowedByCr_utf16le() {
byte[] bytes = "foo\n\r\rbar\r\n".getBytes(StandardCharsets.UTF_16LE); byte[] bytes = "foo\n\r\rbar\r\n".getBytes(UTF_16LE);
ParsableByteArray parser = new ParsableByteArray(bytes); ParsableByteArray parser = new ParsableByteArray(bytes);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo("foo"); assertThat(parser.readLine(UTF_16LE)).isEqualTo("foo");
assertThat(parser.getPosition()).isEqualTo(8); assertThat(parser.getPosition()).isEqualTo(8);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo(""); assertThat(parser.readLine(UTF_16LE)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(10); assertThat(parser.getPosition()).isEqualTo(10);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo(""); assertThat(parser.readLine(UTF_16LE)).isEmpty();
assertThat(parser.getPosition()).isEqualTo(12); assertThat(parser.getPosition()).isEqualTo(12);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isEqualTo("bar"); assertThat(parser.readLine(UTF_16LE)).isEqualTo("bar");
assertThat(parser.getPosition()).isEqualTo(22); assertThat(parser.getPosition()).isEqualTo(22);
assertThat(parser.readLine(StandardCharsets.UTF_16LE)).isNull(); assertThat(parser.readLine(UTF_16LE)).isNull();
} }
@Test @Test