Skip to content

SDK / exoplayer

Go to a project
Commit daafbb1f by andrewlewis Committed by Oliver Woodman
Options

Add missing Robolectric test path to codebase 

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=167151714
parent f15ce81c
Expand all
Inline Side-by-side
Showing with 1307 additions and 0 deletions
library/core/src/test/java/com/google/android/exoplayer2/CTest.java 0 → 100644
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer2;
import static com.google.common.truth.Truth.assertThat;
import android.annotation.SuppressLint;
import android.media.MediaCodec;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Unit test for {@link C}.
*/
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Config.TARGET_SDK, manifest = Config.NONE)
public class CTest {
@SuppressLint("InlinedApi")
@Test
public void testConstants() {
// Sanity check that constant values match those defined by the platform.
assertThat(C.BUFFER_FLAG_KEY_FRAME).isEqualTo(MediaCodec.BUFFER_FLAG_KEY_FRAME);
assertThat(C.BUFFER_FLAG_END_OF_STREAM).isEqualTo(MediaCodec.BUFFER_FLAG_END_OF_STREAM);
assertThat(C.CRYPTO_MODE_AES_CTR).isEqualTo(MediaCodec.CRYPTO_MODE_AES_CTR);
}
}
library/core/src/test/java/com/google/android/exoplayer2/FormatTest.java 0 → 100644
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer2;
import static com.google.android.exoplayer2.C.WIDEVINE_UUID;
import static com.google.android.exoplayer2.util.MimeTypes.VIDEO_MP4;
import static com.google.android.exoplayer2.util.MimeTypes.VIDEO_WEBM;
import static com.google.common.truth.Truth.assertThat;
import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.media.MediaFormat;
import android.os.Parcel;
import com.google.android.exoplayer2.drm.DrmInitData;
import com.google.android.exoplayer2.metadata.Metadata;
import com.google.android.exoplayer2.metadata.id3.TextInformationFrame;
import com.google.android.exoplayer2.testutil.TestUtil;
import com.google.android.exoplayer2.util.MimeTypes;
import com.google.android.exoplayer2.util.Util;
import com.google.android.exoplayer2.video.ColorInfo;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Unit test for {@link Format}.
*/
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Config.TARGET_SDK, manifest = Config.NONE)
public final class FormatTest {
private static final List<byte[]> INIT_DATA;
static {
byte[] initData1 = new byte[] {1, 2, 3};
byte[] initData2 = new byte[] {4, 5, 6};
List<byte[]> initData = new ArrayList<>();
initData.add(initData1);
initData.add(initData2);
INIT_DATA = Collections.unmodifiableList(initData);
}
@Test
public void testParcelable() {
DrmInitData.SchemeData DRM_DATA_1 = new DrmInitData.SchemeData(WIDEVINE_UUID, "cenc", VIDEO_MP4,
TestUtil.buildTestData(128, 1 /* data seed */));
DrmInitData.SchemeData DRM_DATA_2 = new DrmInitData.SchemeData(C.UUID_NIL, null, VIDEO_WEBM,
TestUtil.buildTestData(128, 1 /* data seed */));
DrmInitData drmInitData = new DrmInitData(DRM_DATA_1, DRM_DATA_2);
byte[] projectionData = new byte[] {1, 2, 3};
Metadata metadata = new Metadata(
new TextInformationFrame("id1", "description1", "value1"),
new TextInformationFrame("id2", "description2", "value2"));
ColorInfo colorInfo = new ColorInfo(C.COLOR_SPACE_BT709,
C.COLOR_RANGE_LIMITED, C.COLOR_TRANSFER_SDR, new byte[] {1, 2, 3, 4, 5, 6, 7});
Format formatToParcel = new Format("id", MimeTypes.VIDEO_MP4, MimeTypes.VIDEO_H264, null,
1024, 2048, 1920, 1080, 24, 90, 2, projectionData, C.STEREO_MODE_TOP_BOTTOM, colorInfo, 6,
44100, C.ENCODING_PCM_24BIT, 1001, 1002, 0, "und", Format.NO_VALUE,
Format.OFFSET_SAMPLE_RELATIVE, INIT_DATA, drmInitData, metadata);
Parcel parcel = Parcel.obtain();
formatToParcel.writeToParcel(parcel, 0);
parcel.setDataPosition(0);
Format formatFromParcel = Format.CREATOR.createFromParcel(parcel);
assertThat(formatFromParcel).isEqualTo(formatToParcel);
parcel.recycle();
}
@Test
public void testConversionToFrameworkMediaFormat() {
if (Util.SDK_INT < 16) {
// Test doesn't apply.
return;
}
testConversionToFrameworkMediaFormatV16(Format.createVideoSampleFormat(null, "video/xyz", null,
5000, 102400, 1280, 720, 30, INIT_DATA, null));
testConversionToFrameworkMediaFormatV16(Format.createVideoSampleFormat(null, "video/xyz", null,
5000, Format.NO_VALUE, 1280, 720, 30, null, null));
testConversionToFrameworkMediaFormatV16(Format.createAudioSampleFormat(null, "audio/xyz", null,
500, 128, 5, 44100, INIT_DATA, null, 0, null));
testConversionToFrameworkMediaFormatV16(Format.createAudioSampleFormat(null, "audio/xyz", null,
500, Format.NO_VALUE, 5, 44100, null, null, 0, null));
testConversionToFrameworkMediaFormatV16(Format.createTextSampleFormat(null, "text/xyz", 0,
"eng"));
testConversionToFrameworkMediaFormatV16(Format.createTextSampleFormat(null, "text/xyz", 0,
null));
}
@SuppressLint("InlinedApi")
@TargetApi(16)
private static void testConversionToFrameworkMediaFormatV16(Format in) {
MediaFormat out = in.getFrameworkMediaFormatV16();
assertThat(out.getString(MediaFormat.KEY_MIME)).isEqualTo(in.sampleMimeType);
assertOptionalV16(out, MediaFormat.KEY_LANGUAGE, in.language);
assertOptionalV16(out, MediaFormat.KEY_MAX_INPUT_SIZE, in.maxInputSize);
assertOptionalV16(out, MediaFormat.KEY_WIDTH, in.width);
assertOptionalV16(out, MediaFormat.KEY_HEIGHT, in.height);
assertOptionalV16(out, MediaFormat.KEY_CHANNEL_COUNT, in.channelCount);
assertOptionalV16(out, MediaFormat.KEY_SAMPLE_RATE, in.sampleRate);
assertOptionalV16(out, MediaFormat.KEY_FRAME_RATE, in.frameRate);
for (int i = 0; i < in.initializationData.size(); i++) {
byte[] originalData = in.initializationData.get(i);
ByteBuffer frameworkBuffer = out.getByteBuffer("csd-" + i);
byte[] frameworkData = Arrays.copyOf(frameworkBuffer.array(), frameworkBuffer.limit());
assertThat(frameworkData).isEqualTo(originalData);
}
}
@TargetApi(16)
private static void assertOptionalV16(MediaFormat format, String key, String value) {
if (value == null) {
assertThat(format.containsKey(key)).isEqualTo(false);
} else {
assertThat(format.getString(key)).isEqualTo(value);
}
}
@TargetApi(16)
private static void assertOptionalV16(MediaFormat format, String key, int value) {
if (value == Format.NO_VALUE) {
assertThat(format.containsKey(key)).isEqualTo(false);
} else {
assertThat(format.getInteger(key)).isEqualTo(value);
}
}
@TargetApi(16)
private static void assertOptionalV16(MediaFormat format, String key, float value) {
if (value == Format.NO_VALUE) {
assertThat(format.containsKey(key)).isEqualTo(false);
} else {
assertThat(format.getFloat(key)).isEqualTo(value);
}
}
}
library/core/src/test/java/com/google/android/exoplayer2/util/AtomicFileTest.java 0 → 100644
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer2.util;
import static com.google.common.truth.Truth.assertThat;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
/**
* Tests {@link AtomicFile}.
*/
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Config.TARGET_SDK, manifest = Config.NONE)
public final class AtomicFileTest {
private File tempFolder;
private File file;
private AtomicFile atomicFile;
@Before
public void setUp() throws Exception {
tempFolder = Util.createTempDirectory(RuntimeEnvironment.application, "ExoPlayerTest");
file = new File(tempFolder, "atomicFile");
atomicFile = new AtomicFile(file);
}
@After
public void tearDown() throws Exception {
Util.recursiveDelete(tempFolder);
}
@Test
public void testDelete() throws Exception {
assertThat(file.createNewFile()).isTrue();
atomicFile.delete();
assertThat(file.exists()).isFalse();
}
@Test
public void testWriteRead() throws Exception {
OutputStream output = atomicFile.startWrite();
output.write(5);
atomicFile.endWrite(output);
output.close();
assertRead();
output = atomicFile.startWrite();
output.write(5);
output.write(6);
output.close();
assertRead();
output = atomicFile.startWrite();
output.write(6);
assertRead();
output.close();
output = atomicFile.startWrite();
assertRead();
output.close();
}
private void assertRead() throws IOException {
InputStream input = atomicFile.openRead();
assertThat(input.read()).isEqualTo(5);
assertThat(input.read()).isEqualTo(-1);
input.close();
}
}
library/core/src/test/java/com/google/android/exoplayer2/util/ColorParserTest.java 0 → 100644
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer2.util;
import static android.graphics.Color.BLACK;
import static android.graphics.Color.RED;
import static android.graphics.Color.WHITE;
import static android.graphics.Color.argb;
import static android.graphics.Color.parseColor;
import static com.google.android.exoplayer2.util.ColorParser.parseTtmlColor;
import static com.google.common.truth.Truth.assertThat;
import android.graphics.Color;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Unit test for <code>ColorParser</code>.
*/
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Config.TARGET_SDK, manifest = Config.NONE)
public final class ColorParserTest {
// Negative tests.
@Test(expected = IllegalArgumentException.class)
public void testParseUnknownColor() {
ColorParser.parseTtmlColor("colorOfAnElectron");
}
@Test(expected = IllegalArgumentException.class)
public void testParseNull() {
ColorParser.parseTtmlColor(null);
}
@Test(expected = IllegalArgumentException.class)
public void testParseEmpty() {
ColorParser.parseTtmlColor("");
}
@Test(expected = IllegalArgumentException.class)
public void testRgbColorParsingRgbValuesNegative() {
ColorParser.parseTtmlColor("rgb(-4, 55, 209)");
}
// Positive tests.
@Test
public void testHexCodeParsing() {
assertThat(parseTtmlColor("#FFFFFF")).isEqualTo(WHITE);
assertThat(parseTtmlColor("#FFFFFFFF")).isEqualTo(WHITE);
assertThat(parseTtmlColor("#123456")).isEqualTo(parseColor("#FF123456"));
// Hex colors in ColorParser are RGBA, where-as {@link Color#parseColor} takes ARGB.
assertThat(parseTtmlColor("#FFFFFF00")).isEqualTo(parseColor("#00FFFFFF"));
assertThat(parseTtmlColor("#12345678")).isEqualTo(parseColor("#78123456"));
}
@Test
public void testRgbColorParsing() {
assertThat(parseTtmlColor("rgb(255,255,255)")).isEqualTo(WHITE);
// Spaces are ignored.
assertThat(parseTtmlColor(" rgb ( 255, 255, 255)")).isEqualTo(WHITE);
}
@Test
public void testRgbColorParsingRgbValuesOutOfBounds() {
int outOfBounds = ColorParser.parseTtmlColor("rgb(999, 999, 999)");
int color = Color.rgb(999, 999, 999);
// Behave like the framework does.
assertThat(outOfBounds).isEqualTo(color);
}
@Test
public void testRgbaColorParsing() {
assertThat(parseTtmlColor("rgba(255,255,255,255)")).isEqualTo(WHITE);
assertThat(parseTtmlColor("rgba(255,255,255,255)"))
.isEqualTo(argb(255, 255, 255, 255));
assertThat(parseTtmlColor("rgba(0, 0, 0, 255)")).isEqualTo(BLACK);
assertThat(parseTtmlColor("rgba(0, 0, 255, 0)"))
.isEqualTo(argb(0, 0, 0, 255));
assertThat(parseTtmlColor("rgba(255, 0, 0, 255)")).isEqualTo(RED);
assertThat(parseTtmlColor("rgba(255, 0, 255, 0)"))
.isEqualTo(argb(0, 255, 0, 255));
assertThat(parseTtmlColor("rgba(255, 0, 0, 205)"))
.isEqualTo(argb(205, 255, 0, 0));
}
}
library/core/src/test/java/com/google/android/exoplayer2/util/NalUnitUtilTest.java 0 → 100644
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer2.util;
import static com.google.android.exoplayer2.testutil.TestUtil.createByteArray;
import static com.google.common.truth.Truth.assertThat;
import java.nio.ByteBuffer;
import java.util.Arrays;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Tests for {@link NalUnitUtil}.
*/
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Config.TARGET_SDK, manifest = Config.NONE)
public final class NalUnitUtilTest {
private static final int TEST_PARTIAL_NAL_POSITION = 4;
private static final int TEST_NAL_POSITION = 10;
private static final byte[] SPS_TEST_DATA = createByteArray(0x00, 0x00, 0x01, 0x67, 0x4D, 0x40,
0x16, 0xEC, 0xA0, 0x50, 0x17, 0xFC, 0xB8, 0x08, 0x80, 0x00, 0x00, 0x03, 0x00, 0x80, 0x00,
0x00, 0x0F, 0x47, 0x8B, 0x16, 0xCB);
private static final int SPS_TEST_DATA_OFFSET = 3;
@Test
public void testFindNalUnit() {
byte[] data = buildTestData();
// Should find NAL unit.
int result = NalUnitUtil.findNalUnit(data, 0, data.length, null);
assertThat(result).isEqualTo(TEST_NAL_POSITION);
// Should find NAL unit whose prefix ends one byte before the limit.
result = NalUnitUtil.findNalUnit(data, 0, TEST_NAL_POSITION + 4, null);
assertThat(result).isEqualTo(TEST_NAL_POSITION);
// Shouldn't find NAL unit whose prefix ends at the limit (since the limit is exclusive).
result = NalUnitUtil.findNalUnit(data, 0, TEST_NAL_POSITION + 3, null);
assertThat(result).isEqualTo(TEST_NAL_POSITION + 3);
// Should find NAL unit whose prefix starts at the offset.
result = NalUnitUtil.findNalUnit(data, TEST_NAL_POSITION, data.length, null);
assertThat(result).isEqualTo(TEST_NAL_POSITION);
// Shouldn't find NAL unit whose prefix starts one byte past the offset.
result = NalUnitUtil.findNalUnit(data, TEST_NAL_POSITION + 1, data.length, null);
assertThat(result).isEqualTo(data.length);
}
@Test
public void testFindNalUnitWithPrefix() {
byte[] data = buildTestData();
// First byte of NAL unit in data1, rest in data2.
boolean[] prefixFlags = new boolean[3];
byte[] data1 = Arrays.copyOfRange(data, 0, TEST_NAL_POSITION + 1);
byte[] data2 = Arrays.copyOfRange(data, TEST_NAL_POSITION + 1, data.length);
int result = NalUnitUtil.findNalUnit(data1, 0, data1.length, prefixFlags);
assertThat(result).isEqualTo(data1.length);
result = NalUnitUtil.findNalUnit(data2, 0, data2.length, prefixFlags);
assertThat(result).isEqualTo(-1);
assertPrefixFlagsCleared(prefixFlags);
// First three bytes of NAL unit in data1, rest in data2.
prefixFlags = new boolean[3];
data1 = Arrays.copyOfRange(data, 0, TEST_NAL_POSITION + 3);
data2 = Arrays.copyOfRange(data, TEST_NAL_POSITION + 3, data.length);
result = NalUnitUtil.findNalUnit(data1, 0, data1.length, prefixFlags);
assertThat(result).isEqualTo(data1.length);
result = NalUnitUtil.findNalUnit(data2, 0, data2.length, prefixFlags);
assertThat(result).isEqualTo(-3);
assertPrefixFlagsCleared(prefixFlags);
// First byte of NAL unit in data1, second byte in data2, rest in data3.
prefixFlags = new boolean[3];
data1 = Arrays.copyOfRange(data, 0, TEST_NAL_POSITION + 1);
data2 = Arrays.copyOfRange(data, TEST_NAL_POSITION + 1, TEST_NAL_POSITION + 2);
byte[] data3 = Arrays.copyOfRange(data, TEST_NAL_POSITION + 2, data.length);
result = NalUnitUtil.findNalUnit(data1, 0, data1.length, prefixFlags);
assertThat(result).isEqualTo(data1.length);
result = NalUnitUtil.findNalUnit(data2, 0, data2.length, prefixFlags);
assertThat(result).isEqualTo(data2.length);
result = NalUnitUtil.findNalUnit(data3, 0, data3.length, prefixFlags);
assertThat(result).isEqualTo(-2);
assertPrefixFlagsCleared(prefixFlags);
// NAL unit split with one byte in four arrays.
prefixFlags = new boolean[3];
data1 = Arrays.copyOfRange(data, 0, TEST_NAL_POSITION + 1);
data2 = Arrays.copyOfRange(data, TEST_NAL_POSITION + 1, TEST_NAL_POSITION + 2);
data3 = Arrays.copyOfRange(data, TEST_NAL_POSITION + 2, TEST_NAL_POSITION + 3);
byte[] data4 = Arrays.copyOfRange(data, TEST_NAL_POSITION + 2, data.length);
result = NalUnitUtil.findNalUnit(data1, 0, data1.length, prefixFlags);
assertThat(result).isEqualTo(data1.length);
result = NalUnitUtil.findNalUnit(data2, 0, data2.length, prefixFlags);
assertThat(result).isEqualTo(data2.length);
result = NalUnitUtil.findNalUnit(data3, 0, data3.length, prefixFlags);
assertThat(result).isEqualTo(data3.length);
result = NalUnitUtil.findNalUnit(data4, 0, data4.length, prefixFlags);
assertThat(result).isEqualTo(-3);
assertPrefixFlagsCleared(prefixFlags);
// NAL unit entirely in data2. data1 ends with partial prefix.
prefixFlags = new boolean[3];
data1 = Arrays.copyOfRange(data, 0, TEST_PARTIAL_NAL_POSITION + 2);
data2 = Arrays.copyOfRange(data, TEST_PARTIAL_NAL_POSITION + 2, data.length);
result = NalUnitUtil.findNalUnit(data1, 0, data1.length, prefixFlags);
assertThat(result).isEqualTo(data1.length);
result = NalUnitUtil.findNalUnit(data2, 0, data2.length, prefixFlags);
assertThat(result).isEqualTo(4);
assertPrefixFlagsCleared(prefixFlags);
}
@Test
public void testParseSpsNalUnit() {
NalUnitUtil.SpsData data = NalUnitUtil.parseSpsNalUnit(SPS_TEST_DATA, SPS_TEST_DATA_OFFSET,
SPS_TEST_DATA.length);
assertThat(data.width).isEqualTo(640);
assertThat(data.height).isEqualTo(360);
assertThat(data.deltaPicOrderAlwaysZeroFlag).isFalse();
assertThat(data.frameMbsOnlyFlag).isTrue();
assertThat(data.frameNumLength).isEqualTo(4);
assertThat(data.picOrderCntLsbLength).isEqualTo(6);
assertThat(data.seqParameterSetId).isEqualTo(0);
assertThat(data.pixelWidthAspectRatio).isEqualTo(1.0f);
assertThat(data.picOrderCountType).isEqualTo(0);
assertThat(data.separateColorPlaneFlag).isFalse();
}
@Test
public void testUnescapeDoesNotModifyBuffersWithoutStartCodes() {
assertUnescapeDoesNotModify("");
assertUnescapeDoesNotModify("0000");
assertUnescapeDoesNotModify("172BF38A3C");
assertUnescapeDoesNotModify("000004");
}
@Test
public void testUnescapeModifiesBuffersWithStartCodes() {
assertUnescapeMatchesExpected("00000301", "000001");
assertUnescapeMatchesExpected("0000030200000300", "000002000000");
}
@Test
public void testDiscardToSps() {
assertDiscardToSpsMatchesExpected("", "");
assertDiscardToSpsMatchesExpected("00", "");
assertDiscardToSpsMatchesExpected("FFFF000001", "");
assertDiscardToSpsMatchesExpected("00000001", "");
assertDiscardToSpsMatchesExpected("00000001FF67", "");
assertDiscardToSpsMatchesExpected("00000001000167", "");
assertDiscardToSpsMatchesExpected("0000000167", "0000000167");
assertDiscardToSpsMatchesExpected("0000000167FF", "0000000167FF");
assertDiscardToSpsMatchesExpected("0000000167FF", "0000000167FF");
assertDiscardToSpsMatchesExpected("0000000167FF000000016700", "0000000167FF000000016700");
assertDiscardToSpsMatchesExpected("000000000167FF", "0000000167FF");
assertDiscardToSpsMatchesExpected("0001670000000167FF", "0000000167FF");
assertDiscardToSpsMatchesExpected("FF00000001660000000167FF", "0000000167FF");
}
private static byte[] buildTestData() {
byte[] data = new byte[20];
for (int i = 0; i < data.length; i++) {
data[i] = (byte) 0xFF;
}
// Insert an incomplete NAL unit start code.
data[TEST_PARTIAL_NAL_POSITION] = 0;
data[TEST_PARTIAL_NAL_POSITION + 1] = 0;
// Insert a complete NAL unit start code.
data[TEST_NAL_POSITION] = 0;
data[TEST_NAL_POSITION + 1] = 0;
data[TEST_NAL_POSITION + 2] = 1;
data[TEST_NAL_POSITION + 3] = 5;
return data;
}
private static void assertPrefixFlagsCleared(boolean[] flags) {
assertThat(flags[0] || flags[1] || flags[2]).isEqualTo(false);
}
private static void assertUnescapeDoesNotModify(String input) {
assertUnescapeMatchesExpected(input, input);
}
private static void assertUnescapeMatchesExpected(String input, String expectedOutput) {
byte[] bitstream = Util.getBytesFromHexString(input);
byte[] expectedOutputBitstream = Util.getBytesFromHexString(expectedOutput);
int count = NalUnitUtil.unescapeStream(bitstream, bitstream.length);
assertThat(count).isEqualTo(expectedOutputBitstream.length);
byte[] outputBitstream = new byte[count];
System.arraycopy(bitstream, 0, outputBitstream, 0, count);
assertThat(outputBitstream).isEqualTo(expectedOutputBitstream);
}
private static void assertDiscardToSpsMatchesExpected(String input, String expectedOutput) {
byte[] bitstream = Util.getBytesFromHexString(input);
byte[] expectedOutputBitstream = Util.getBytesFromHexString(expectedOutput);
ByteBuffer buffer = ByteBuffer.wrap(bitstream);
buffer.position(buffer.limit());
NalUnitUtil.discardToSps(buffer);
assertThat(Arrays.copyOf(buffer.array(), buffer.position())).isEqualTo(expectedOutputBitstream);
}
}
library/core/src/test/java/com/google/android/exoplayer2/util/ParsableBitArrayTest.java 0 → 100644
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer2.util;
import static com.google.common.truth.Truth.assertThat;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Tests for {@link ParsableBitArray}.
*/
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Config.TARGET_SDK, manifest = Config.NONE)
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
public void testReadAllBytes() {
byte[] bytesRead = new byte[TEST_DATA.length];
testArray.readBytes(bytesRead, 0, TEST_DATA.length);
assertThat(bytesRead).isEqualTo(TEST_DATA);
assertThat(testArray.getPosition()).isEqualTo(TEST_DATA.length * 8);
assertThat(testArray.getBytePosition()).isEqualTo(TEST_DATA.length);
}
@Test
public void testReadBit() {
assertReadBitsToEnd(0);
}
@Test
public void testReadBits() {
assertThat(testArray.readBits(5)).isEqualTo(getTestDataBits(0, 5));
assertThat(testArray.readBits(0)).isEqualTo(getTestDataBits(5, 0));
assertThat(testArray.readBits(3)).isEqualTo(getTestDataBits(5, 3));
assertThat(testArray.readBits(16)).isEqualTo(getTestDataBits(8, 16));
assertThat(testArray.readBits(3)).isEqualTo(getTestDataBits(24, 3));
assertThat(testArray.readBits(18)).isEqualTo(getTestDataBits(27, 18));
assertThat(testArray.readBits(5)).isEqualTo(getTestDataBits(45, 5));
assertThat(testArray.readBits(14)).isEqualTo(getTestDataBits(50, 14));
}
@Test
public void testReadBitsToByteArray() {
byte[] result = new byte[TEST_DATA.length];
// Test read within byte boundaries.
testArray.readBits(result, 0, 6);
assertThat(result[0]).isEqualTo((byte) (TEST_DATA[0] & 0xFC));
// Test read across byte boundaries.
testArray.readBits(result, 0, 8);
assertThat(result[0]).isEqualTo(
(byte) (((TEST_DATA[0] & 0x03) << 6) | ((TEST_DATA[1] & 0xFC) >> 2)));
// Test reading across multiple bytes.
testArray.readBits(result, 1, 50);
for (int i = 1; i < 7; i++) {
assertThat(result[i])
.isEqualTo((byte) (((TEST_DATA[i] & 0x03) << 6) | ((TEST_DATA[i + 1] & 0xFC) >> 2)));
}
assertThat(result[7]).isEqualTo((byte) ((TEST_DATA[7] & 0x03) << 6));
assertThat(testArray.bitsLeft()).isEqualTo(0);
// Test read last buffer byte across input data bytes.
testArray.setPosition(31);
result[3] = 0;
testArray.readBits(result, 3, 3);
assertThat(result[3]).isEqualTo((byte) 0xE0);
// Test read bits in the middle of a input data byte.
result[0] = 0;
assertThat(testArray.getPosition()).isEqualTo(34);
testArray.readBits(result, 0, 3);
assertThat(result[0]).isEqualTo((byte) 0xE0);
// Test read 0 bits.
testArray.setPosition(32);
result[1] = 0;
testArray.readBits(result, 1, 0);
assertThat(result[1]).isEqualTo((byte) 0);
// Test reading a number of bits divisible by 8.
testArray.setPosition(0);
testArray.readBits(result, 0, 16);
assertThat(result[0]).isEqualTo(TEST_DATA[0]);
assertThat(result[1]).isEqualTo(TEST_DATA[1]);
// Test least significant bits are unmodified.
result[1] = (byte) 0xFF;
testArray.readBits(result, 0, 9);
assertThat(result[0]).isEqualTo((byte) 0x5F);
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
public void testSkipBytes() {
testArray.skipBytes(2);
assertReadBitsToEnd(16);
}
@Test
public void testSkipBitsByteAligned() {
testArray.skipBits(16);
assertReadBitsToEnd(16);
}
@Test
public void testSkipBitsNonByteAligned() {
testArray.skipBits(5);
assertReadBitsToEnd(5);
}
@Test
public void testSetPositionByteAligned() {
testArray.setPosition(16);
assertReadBitsToEnd(16);
}
@Test
public void testSetPositionNonByteAligned() {
testArray.setPosition(5);
assertReadBitsToEnd(5);
}
@Test
public void testByteAlignFromNonByteAligned() {
testArray.setPosition(11);
testArray.byteAlign();
assertThat(testArray.getBytePosition()).isEqualTo(2);
assertThat(testArray.getPosition()).isEqualTo(16);
assertReadBitsToEnd(16);
}
@Test
public void testByteAlignFromByteAligned() {
testArray.setPosition(16);
testArray.byteAlign(); // Should be a no-op.
assertThat(testArray.getBytePosition()).isEqualTo(2);
assertThat(testArray.getPosition()).isEqualTo(16);
assertReadBitsToEnd(16);
}
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;
}
}
library/core/src/test/java/com/google/android/exoplayer2/util/ParsableNalUnitBitArrayTest.java 0 → 100644
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer2.util;
import static com.google.android.exoplayer2.testutil.TestUtil.createByteArray;
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.fail;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Tests for {@link ParsableNalUnitBitArray}.
*/
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Config.TARGET_SDK, manifest = Config.NONE)
public final class ParsableNalUnitBitArrayTest {
private static final byte[] NO_ESCAPING_TEST_DATA = createByteArray(0, 3, 0, 1, 3, 0, 0);
private static final byte[] ALL_ESCAPING_TEST_DATA = createByteArray(0, 0, 3, 0, 0, 3, 0, 0, 3);
private static final byte[] MIX_TEST_DATA = createByteArray(255, 0, 0, 3, 255, 0, 0, 127);
@Test
public void testReadNoEscaping() {
ParsableNalUnitBitArray array =
new ParsableNalUnitBitArray(NO_ESCAPING_TEST_DATA, 0, NO_ESCAPING_TEST_DATA.length);
assertThat(array.readBits(24)).isEqualTo(0x000300);
assertThat(array.readBits(7)).isEqualTo(0);
assertThat(array.readBit()).isTrue();
assertThat(array.readBits(24)).isEqualTo(0x030000);
assertThat(array.canReadBits(1)).isFalse();
assertThat(array.canReadBits(8)).isFalse();
}
@Test
public void testReadNoEscapingTruncated() {
ParsableNalUnitBitArray array = new ParsableNalUnitBitArray(NO_ESCAPING_TEST_DATA, 0, 4);
assertThat(array.canReadBits(32)).isTrue();
array.skipBits(32);
assertThat(array.canReadBits(1)).isFalse();
try {
array.readBit();
fail();
} catch (Exception e) {
// Expected.
}
}
@Test
public void testReadAllEscaping() {
ParsableNalUnitBitArray array =
new ParsableNalUnitBitArray(ALL_ESCAPING_TEST_DATA, 0, ALL_ESCAPING_TEST_DATA.length);
assertThat(array.canReadBits(48)).isTrue();
assertThat(array.canReadBits(49)).isFalse();
assertThat(array.readBits(15)).isEqualTo(0);
assertThat(array.readBit()).isFalse();
assertThat(array.readBits(17)).isEqualTo(0);
assertThat(array.readBits(15)).isEqualTo(0);
}
@Test
public void testReadMix() {
ParsableNalUnitBitArray array =
new ParsableNalUnitBitArray(MIX_TEST_DATA, 0, MIX_TEST_DATA.length);
assertThat(array.canReadBits(56)).isTrue();
assertThat(array.canReadBits(57)).isFalse();
assertThat(array.readBits(7)).isEqualTo(127);
assertThat(array.readBits(2)).isEqualTo(2);
assertThat(array.readBits(17)).isEqualTo(3);
assertThat(array.readBits(7)).isEqualTo(126);
assertThat(array.readBits(23)).isEqualTo(127);
assertThat(array.canReadBits(1)).isFalse();
}
@Test
public void testReadExpGolomb() {
ParsableNalUnitBitArray array = new ParsableNalUnitBitArray(createByteArray(0x9E), 0, 1);
assertThat(array.canReadExpGolombCodedNum()).isTrue();
assertThat(array.readUnsignedExpGolombCodedInt()).isEqualTo(0);
assertThat(array.readUnsignedExpGolombCodedInt()).isEqualTo(6);
assertThat(array.readUnsignedExpGolombCodedInt()).isEqualTo(0);
assertThat(array.canReadExpGolombCodedNum()).isFalse();
try {
array.readUnsignedExpGolombCodedInt();
fail();
} catch (Exception e) {
// Expected.
}
}
@Test
public void testReadExpGolombWithEscaping() {
ParsableNalUnitBitArray array =
new ParsableNalUnitBitArray(createByteArray(0, 0, 3, 128, 0), 0, 5);
assertThat(array.canReadExpGolombCodedNum()).isFalse();
array.skipBit();
assertThat(array.canReadExpGolombCodedNum()).isTrue();
assertThat(array.readUnsignedExpGolombCodedInt()).isEqualTo(32767);
assertThat(array.canReadBits(1)).isFalse();
}
@Test
public void testReset() {
ParsableNalUnitBitArray array = new ParsableNalUnitBitArray(createByteArray(0, 0), 0, 2);
assertThat(array.canReadExpGolombCodedNum()).isFalse();
assertThat(array.canReadBits(16)).isTrue();
assertThat(array.canReadBits(17)).isFalse();
array.reset(createByteArray(0, 0, 3, 0), 0, 4);
assertThat(array.canReadBits(24)).isTrue();
assertThat(array.canReadBits(25)).isFalse();
}
}
library/core/src/test/java/com/google/android/exoplayer2/util/ReusableBufferedOutputStreamTest.java 0 → 100644
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer2.util;
import static com.google.common.truth.Truth.assertThat;
import java.io.ByteArrayOutputStream;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Tests {@link ReusableBufferedOutputStream}.
*/
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Config.TARGET_SDK, manifest = Config.NONE)
public final class ReusableBufferedOutputStreamTest {
private static final byte[] TEST_DATA_1 = "test data 1".getBytes();
private static final byte[] TEST_DATA_2 = "2 test data".getBytes();
@Test
public void testReset() throws Exception {
ByteArrayOutputStream byteArrayOutputStream1 = new ByteArrayOutputStream(1000);
ReusableBufferedOutputStream outputStream = new ReusableBufferedOutputStream(
byteArrayOutputStream1, 1000);
outputStream.write(TEST_DATA_1);
outputStream.close();
ByteArrayOutputStream byteArrayOutputStream2 = new ByteArrayOutputStream(1000);
outputStream.reset(byteArrayOutputStream2);
outputStream.write(TEST_DATA_2);
outputStream.close();
assertThat(byteArrayOutputStream1.toByteArray()).isEqualTo(TEST_DATA_1);
assertThat(byteArrayOutputStream2.toByteArray()).isEqualTo(TEST_DATA_2);
}
}
library/core/src/test/java/com/google/android/exoplayer2/util/UriUtilTest.java 0 → 100644
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer2.util;
import static com.google.android.exoplayer2.util.UriUtil.resolve;
import static com.google.common.truth.Truth.assertThat;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Unit tests for {@link UriUtil}.
*/
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Config.TARGET_SDK, manifest = Config.NONE)
public final class UriUtilTest {
/**
* Tests normal usage of {@link UriUtil#resolve(String, String)}.
* <p>
* The test cases are taken from RFC-3986 5.4.1.
*/
@Test
public void testResolveNormal() {
String base = "http://a/b/c/d;p?q";
assertThat(resolve(base, "g:h")).isEqualTo("g:h");
assertThat(resolve(base, "g")).isEqualTo("http://a/b/c/g");
assertThat(resolve(base, "g/")).isEqualTo("http://a/b/c/g/");
assertThat(resolve(base, "/g")).isEqualTo("http://a/g");
assertThat(resolve(base, "//g")).isEqualTo("http://g");
assertThat(resolve(base, "?y")).isEqualTo("http://a/b/c/d;p?y");
assertThat(resolve(base, "g?y")).isEqualTo("http://a/b/c/g?y");
assertThat(resolve(base, "#s")).isEqualTo("http://a/b/c/d;p?q#s");
assertThat(resolve(base, "g#s")).isEqualTo("http://a/b/c/g#s");
assertThat(resolve(base, "g?y#s")).isEqualTo("http://a/b/c/g?y#s");
assertThat(resolve(base, ";x")).isEqualTo("http://a/b/c/;x");
assertThat(resolve(base, "g;x")).isEqualTo("http://a/b/c/g;x");
assertThat(resolve(base, "g;x?y#s")).isEqualTo("http://a/b/c/g;x?y#s");
assertThat(resolve(base, "")).isEqualTo("http://a/b/c/d;p?q");
assertThat(resolve(base, ".")).isEqualTo("http://a/b/c/");
assertThat(resolve(base, "./")).isEqualTo("http://a/b/c/");
assertThat(resolve(base, "..")).isEqualTo("http://a/b/");
assertThat(resolve(base, "../")).isEqualTo("http://a/b/");
assertThat(resolve(base, "../g")).isEqualTo("http://a/b/g");
assertThat(resolve(base, "../..")).isEqualTo("http://a/");
assertThat(resolve(base, "../../")).isEqualTo("http://a/");
assertThat(resolve(base, "../../g")).isEqualTo("http://a/g");
}
/**
* Tests abnormal usage of {@link UriUtil#resolve(String, String)}.
* <p>
* The test cases are taken from RFC-3986 5.4.2.
*/
@Test
public void testResolveAbnormal() {
String base = "http://a/b/c/d;p?q";
assertThat(resolve(base, "../../../g")).isEqualTo("http://a/g");
assertThat(resolve(base, "../../../../g")).isEqualTo("http://a/g");
assertThat(resolve(base, "/./g")).isEqualTo("http://a/g");
assertThat(resolve(base, "/../g")).isEqualTo("http://a/g");
assertThat(resolve(base, "g.")).isEqualTo("http://a/b/c/g.");
assertThat(resolve(base, ".g")).isEqualTo("http://a/b/c/.g");
assertThat(resolve(base, "g..")).isEqualTo("http://a/b/c/g..");
assertThat(resolve(base, "..g")).isEqualTo("http://a/b/c/..g");
assertThat(resolve(base, "./../g")).isEqualTo("http://a/b/g");
assertThat(resolve(base, "./g/.")).isEqualTo("http://a/b/c/g/");
assertThat(resolve(base, "g/./h")).isEqualTo("http://a/b/c/g/h");
assertThat(resolve(base, "g/../h")).isEqualTo("http://a/b/c/h");
assertThat(resolve(base, "g;x=1/./y")).isEqualTo("http://a/b/c/g;x=1/y");
assertThat(resolve(base, "g;x=1/../y")).isEqualTo("http://a/b/c/y");
assertThat(resolve(base, "g?y/./x")).isEqualTo("http://a/b/c/g?y/./x");
assertThat(resolve(base, "g?y/../x")).isEqualTo("http://a/b/c/g?y/../x");
assertThat(resolve(base, "g#s/./x")).isEqualTo("http://a/b/c/g#s/./x");
assertThat(resolve(base, "g#s/../x")).isEqualTo("http://a/b/c/g#s/../x");
assertThat(resolve(base, "http:g")).isEqualTo("http:g");
}
/**
* Tests additional abnormal usage of {@link UriUtil#resolve(String, String)}.
*/
@Test
public void testResolveAbnormalAdditional() {
assertThat(resolve("http://a/b", "c:d/../e")).isEqualTo("c:e");
assertThat(resolve("a:b", "../c")).isEqualTo("a:c");
}
}
library/core/src/test/java/com/google/android/exoplayer2/util/UtilTest.java 0 → 100644
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.android.exoplayer2.util;
import static com.google.android.exoplayer2.util.Util.binarySearchCeil;
import static com.google.android.exoplayer2.util.Util.binarySearchFloor;
import static com.google.android.exoplayer2.util.Util.escapeFileName;
import static com.google.android.exoplayer2.util.Util.parseXsDateTime;
import static com.google.android.exoplayer2.util.Util.parseXsDuration;
import static com.google.android.exoplayer2.util.Util.unescapeFileName;
import static com.google.common.truth.Truth.assertThat;
import com.google.android.exoplayer2.testutil.TestUtil;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
/**
* Unit tests for {@link Util}.
*/
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Config.TARGET_SDK, manifest = Config.NONE)
public class UtilTest {
@Test
public void testArrayBinarySearchFloor() {
long[] values = new long[0];
assertThat(binarySearchFloor(values, 0, false, false)).isEqualTo(-1);
assertThat(binarySearchFloor(values, 0, false, true)).isEqualTo(0);
values = new long[] {1, 3, 5};
assertThat(binarySearchFloor(values, 0, false, false)).isEqualTo(-1);
assertThat(binarySearchFloor(values, 0, true, false)).isEqualTo(-1);
assertThat(binarySearchFloor(values, 0, false, true)).isEqualTo(0);
assertThat(binarySearchFloor(values, 0, true, true)).isEqualTo(0);
assertThat(binarySearchFloor(values, 1, false, false)).isEqualTo(-1);
assertThat(binarySearchFloor(values, 1, true, false)).isEqualTo(0);
assertThat(binarySearchFloor(values, 1, false, true)).isEqualTo(0);
assertThat(binarySearchFloor(values, 1, true, true)).isEqualTo(0);
assertThat(binarySearchFloor(values, 4, false, false)).isEqualTo(1);
assertThat(binarySearchFloor(values, 4, true, false)).isEqualTo(1);
assertThat(binarySearchFloor(values, 5, false, false)).isEqualTo(1);
assertThat(binarySearchFloor(values, 5, true, false)).isEqualTo(2);
assertThat(binarySearchFloor(values, 6, false, false)).isEqualTo(2);
assertThat(binarySearchFloor(values, 6, true, false)).isEqualTo(2);
}
@Test
public void testListBinarySearchFloor() {
List<Integer> values = new ArrayList<>();
assertThat(binarySearchFloor(values, 0, false, false)).isEqualTo(-1);
assertThat(binarySearchFloor(values, 0, false, true)).isEqualTo(0);
values.add(1);
values.add(3);
values.add(5);
assertThat(binarySearchFloor(values, 0, false, false)).isEqualTo(-1);
assertThat(binarySearchFloor(values, 0, true, false)).isEqualTo(-1);
assertThat(binarySearchFloor(values, 0, false, true)).isEqualTo(0);
assertThat(binarySearchFloor(values, 0, true, true)).isEqualTo(0);
assertThat(binarySearchFloor(values, 1, false, false)).isEqualTo(-1);
assertThat(binarySearchFloor(values, 1, true, false)).isEqualTo(0);
assertThat(binarySearchFloor(values, 1, false, true)).isEqualTo(0);
assertThat(binarySearchFloor(values, 1, true, true)).isEqualTo(0);
assertThat(binarySearchFloor(values, 4, false, false)).isEqualTo(1);
assertThat(binarySearchFloor(values, 4, true, false)).isEqualTo(1);
assertThat(binarySearchFloor(values, 5, false, false)).isEqualTo(1);
assertThat(binarySearchFloor(values, 5, true, false)).isEqualTo(2);
assertThat(binarySearchFloor(values, 6, false, false)).isEqualTo(2);
assertThat(binarySearchFloor(values, 6, true, false)).isEqualTo(2);
}
@Test
public void testArrayBinarySearchCeil() {
long[] values = new long[0];
assertThat(binarySearchCeil(values, 0, false, false)).isEqualTo(0);
assertThat(binarySearchCeil(values, 0, false, true)).isEqualTo(-1);
values = new long[] {1, 3, 5};
assertThat(binarySearchCeil(values, 0, false, false)).isEqualTo(0);
assertThat(binarySearchCeil(values, 0, true, false)).isEqualTo(0);
assertThat(binarySearchCeil(values, 1, false, false)).isEqualTo(1);
assertThat(binarySearchCeil(values, 1, true, false)).isEqualTo(0);
assertThat(binarySearchCeil(values, 2, false, false)).isEqualTo(1);
assertThat(binarySearchCeil(values, 2, true, false)).isEqualTo(1);
assertThat(binarySearchCeil(values, 5, false, false)).isEqualTo(3);
assertThat(binarySearchCeil(values, 5, true, false)).isEqualTo(2);
assertThat(binarySearchCeil(values, 5, false, true)).isEqualTo(2);
assertThat(binarySearchCeil(values, 5, true, true)).isEqualTo(2);
assertThat(binarySearchCeil(values, 6, false, false)).isEqualTo(3);
assertThat(binarySearchCeil(values, 6, true, false)).isEqualTo(3);
assertThat(binarySearchCeil(values, 6, false, true)).isEqualTo(2);
assertThat(binarySearchCeil(values, 6, true, true)).isEqualTo(2);
}
@Test
public void testListBinarySearchCeil() {
List<Integer> values = new ArrayList<>();
assertThat(binarySearchCeil(values, 0, false, false)).isEqualTo(0);
assertThat(binarySearchCeil(values, 0, false, true)).isEqualTo(-1);
values.add(1);
values.add(3);
values.add(5);
assertThat(binarySearchCeil(values, 0, false, false)).isEqualTo(0);
assertThat(binarySearchCeil(values, 0, true, false)).isEqualTo(0);
assertThat(binarySearchCeil(values, 1, false, false)).isEqualTo(1);
assertThat(binarySearchCeil(values, 1, true, false)).isEqualTo(0);
assertThat(binarySearchCeil(values, 2, false, false)).isEqualTo(1);
assertThat(binarySearchCeil(values, 2, true, false)).isEqualTo(1);
assertThat(binarySearchCeil(values, 5, false, false)).isEqualTo(3);
assertThat(binarySearchCeil(values, 5, true, false)).isEqualTo(2);
assertThat(binarySearchCeil(values, 5, false, true)).isEqualTo(2);
assertThat(binarySearchCeil(values, 5, true, true)).isEqualTo(2);
assertThat(binarySearchCeil(values, 6, false, false)).isEqualTo(3);
assertThat(binarySearchCeil(values, 6, true, false)).isEqualTo(3);
assertThat(binarySearchCeil(values, 6, false, true)).isEqualTo(2);
assertThat(binarySearchCeil(values, 6, true, true)).isEqualTo(2);
}
@Test
public void testParseXsDuration() {
assertThat(parseXsDuration("PT150.279S")).isEqualTo(150279L);
assertThat(parseXsDuration("PT1.500S")).isEqualTo(1500L);
}
@Test
public void testParseXsDateTime() throws Exception {
assertThat(parseXsDateTime("2014-06-19T23:07:42")).isEqualTo(1403219262000L);
assertThat(parseXsDateTime("2014-08-06T11:00:00Z")).isEqualTo(1407322800000L);
assertThat(parseXsDateTime("2014-08-06T11:00:00,000Z")).isEqualTo(1407322800000L);
assertThat(parseXsDateTime("2014-09-19T13:18:55-08:00")).isEqualTo(1411161535000L);
assertThat(parseXsDateTime("2014-09-19T13:18:55-0800")).isEqualTo(1411161535000L);
assertThat(parseXsDateTime("2014-09-19T13:18:55.000-0800")).isEqualTo(1411161535000L);
assertThat(parseXsDateTime("2014-09-19T13:18:55.000-800")).isEqualTo(1411161535000L);
}
@Test
public void testUnescapeInvalidFileName() {
assertThat(Util.unescapeFileName("%a")).isNull();
assertThat(Util.unescapeFileName("%xyz")).isNull();
}
@Test
public void testEscapeUnescapeFileName() {
assertEscapeUnescapeFileName("just+a regular+fileName", "just+a regular+fileName");
assertEscapeUnescapeFileName("key:value", "key%3avalue");
assertEscapeUnescapeFileName("<>:\"/\\|?*%", "%3c%3e%3a%22%2f%5c%7c%3f%2a%25");
Random random = new Random(0);
for (int i = 0; i < 1000; i++) {
String string = TestUtil.buildTestString(1000, random);
assertEscapeUnescapeFileName(string);
}
}
private static void assertEscapeUnescapeFileName(String fileName, String escapedFileName) {
assertThat(escapeFileName(fileName)).isEqualTo(escapedFileName);
assertThat(unescapeFileName(escapedFileName)).isEqualTo(fileName);
}
private static void assertEscapeUnescapeFileName(String fileName) {
String escapedFileName = Util.escapeFileName(fileName);
assertThat(unescapeFileName(escapedFileName)).isEqualTo(fileName);
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment