/*
* Copyright (C) 2009 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.android.mediaframeworktest.unit;
import android.media.Metadata;
import android.os.Parcel;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.SmallTest;
import android.util.Log;
import java.util.Calendar;
import java.util.Date;
/*
* Check the Java layer that parses serialized metadata in Parcel
* works as expected.
*
*/
public class MediaPlayerMetadataParserTest extends AndroidTestCase {
private static final String TAG = "MediaPlayerMetadataTest";
private static final int kMarker = 0x4d455441; // 'M' 'E' 'T' 'A'
private static final int kHeaderSize = 8;
private Metadata mMetadata = null;
private Parcel mParcel = null;
@Override
protected void setUp() throws Exception {
super.setUp();
mMetadata = new Metadata();
mParcel = Parcel.obtain();
resetParcel();
}
// Check parsing of the parcel fails. Make sure the parser rewind
// the parcel properly.
private void assertParseFail() throws Exception {
mParcel.setDataPosition(0);
assertFalse(mMetadata.parse(mParcel));
assertEquals(0, mParcel.dataPosition());
}
// Check parsing of the parcel is successful.
private void assertParse() throws Exception {
mParcel.setDataPosition(0);
assertTrue(mMetadata.parse(mParcel));
}
// Write the number of bytes from the start of the parcel to the
// current position at the beginning of the parcel (offset 0).
private void adjustSize() {
adjustSize(0);
}
// Write the number of bytes from the offset to the current
// position at position pointed by offset.
private void adjustSize(int offset) {
final int pos = mParcel.dataPosition();
mParcel.setDataPosition(offset);
mParcel.writeInt(pos - offset);
mParcel.setDataPosition(pos);
}
// Rewind the parcel and insert the header.
private void resetParcel() {
mParcel.setDataPosition(0);
// Most tests will use a properly formed parcel with a size
// and the meta marker so we add them by default.
mParcel.writeInt(-1); // Placeholder for the size
mParcel.writeInt(kMarker);
}
// ----------------------------------------------------------------------
// START OF THE TESTS
// There should be at least 8 bytes in the parcel, 4 for the size
// and 4 for the 'M' 'E' 'T' 'A' marker.
@SmallTest
public void testMissingSizeAndMarker() throws Exception {
for (int i = 0; i < kHeaderSize; ++i) {
mParcel.setDataPosition(0);
mParcel.setDataSize(i);
assertEquals(i, mParcel.dataAvail());
assertParseFail();
}
}
// There should be at least 'size' bytes in the parcel.
@SmallTest
public void testMissingData() throws Exception {
final int size = 20;
mParcel.writeInt(size);
mParcel.setDataSize(size - 1);
assertParseFail();
}
// Empty parcel is fine
@SmallTest
public void testEmptyIsOk() throws Exception {
adjustSize();
assertParse();
}
// ----------------------------------------------------------------------
// RECORDS
// ----------------------------------------------------------------------
// A record header should be at least 12 bytes long
@SmallTest
public void testRecordMissingId() throws Exception {
mParcel.writeInt(13); // record length
// misses metadata id and metadata type.
adjustSize();
assertParseFail();
}
@SmallTest
public void testRecordMissingType() throws Exception {
mParcel.writeInt(13); // record length lies
mParcel.writeInt(Metadata.TITLE);
// misses metadata type
adjustSize();
assertParseFail();
}
@SmallTest
public void testRecordWithZeroPayload() throws Exception {
mParcel.writeInt(0);
adjustSize();
assertParseFail();
}
// A record cannot be empty.
@SmallTest
public void testRecordMissingPayload() throws Exception {
mParcel.writeInt(12);
mParcel.writeInt(Metadata.TITLE);
mParcel.writeInt(Metadata.STRING_VAL);
// misses payload
adjustSize();
assertParseFail();
}
// Check records can be found.
@SmallTest
public void testRecordsFound() throws Exception {
writeStringRecord(Metadata.TITLE, "a title");
writeStringRecord(Metadata.GENRE, "comedy");
writeStringRecord(Metadata.firstCustomId(), "custom");
adjustSize();
assertParse();
assertTrue(mMetadata.has(Metadata.TITLE));
assertTrue(mMetadata.has(Metadata.GENRE));
assertTrue(mMetadata.has(Metadata.firstCustomId()));
assertFalse(mMetadata.has(Metadata.DRM_CRIPPLED));
assertEquals(3, mMetadata.keySet().size());
}
// Detects bad metadata type
@SmallTest
public void testBadMetadataType() throws Exception {
final int start = mParcel.dataPosition();
mParcel.writeInt(-1); // Placeholder for the length
mParcel.writeInt(Metadata.TITLE);
mParcel.writeInt(0); // Invalid type.
mParcel.writeString("dummy");
adjustSize(start);
adjustSize();
assertParseFail();
}
// Check a Metadata instance can be reused, i.e the parse method
// wipes out the existing states/keys.
@SmallTest
public void testParseClearState() throws Exception {
writeStringRecord(Metadata.TITLE, "a title");
writeStringRecord(Metadata.GENRE, "comedy");
writeStringRecord(Metadata.firstCustomId(), "custom");
adjustSize();
assertParse();
resetParcel();
writeStringRecord(Metadata.MIME_TYPE, "audio/mpg");
adjustSize();
assertParse();
// Only the mime type metadata should be present.
assertEquals(1, mMetadata.keySet().size());
assertTrue(mMetadata.has(Metadata.MIME_TYPE));
assertFalse(mMetadata.has(Metadata.TITLE));
assertFalse(mMetadata.has(Metadata.GENRE));
assertFalse(mMetadata.has(Metadata.firstCustomId()));
}
// ----------------------------------------------------------------------
// GETTERS
// ----------------------------------------------------------------------
// getString
@SmallTest
public void testGetString() throws Exception {
writeStringRecord(Metadata.TITLE, "a title");
writeStringRecord(Metadata.GENRE, "comedy");
adjustSize();
assertParse();
assertEquals("a title", mMetadata.getString(Metadata.TITLE));
assertEquals("comedy", mMetadata.getString(Metadata.GENRE));
}
// get an empty string.
@SmallTest
public void testGetEmptyString() throws Exception {
writeStringRecord(Metadata.TITLE, "");
adjustSize();
assertParse();
assertEquals("", mMetadata.getString(Metadata.TITLE));
}
// get a string when a NULL value was in the parcel
@SmallTest
public void testGetNullString() throws Exception {
writeStringRecord(Metadata.TITLE, null);
adjustSize();
assertParse();
assertEquals(null, mMetadata.getString(Metadata.TITLE));
}
// get a string when an integer is actually present
@SmallTest
public void testWrongType() throws Exception {
writeIntRecord(Metadata.DURATION, 5);
adjustSize();
assertParse();
try {
mMetadata.getString(Metadata.DURATION);
} catch (IllegalStateException ise) {
return;
}
fail("Exception was not thrown");
}
// getInt
@SmallTest
public void testGetInt() throws Exception {
writeIntRecord(Metadata.CD_TRACK_NUM, 1);
adjustSize();
assertParse();
assertEquals(1, mMetadata.getInt(Metadata.CD_TRACK_NUM));
}
// getBoolean
@SmallTest
public void testGetBoolean() throws Exception {
writeBooleanRecord(Metadata.PAUSE_AVAILABLE, true);
writeBooleanRecord(Metadata.SEEK_AVAILABLE, true);
writeBooleanRecord(Metadata.SEEK_BACKWARD_AVAILABLE, true);
writeBooleanRecord(Metadata.SEEK_FORWARD_AVAILABLE, true);
adjustSize();
assertParse();
assertEquals(true, mMetadata.getBoolean(Metadata.PAUSE_AVAILABLE));
assertEquals(true, mMetadata.getBoolean(Metadata.SEEK_AVAILABLE));
assertEquals(true, mMetadata.getBoolean(Metadata.SEEK_BACKWARD_AVAILABLE));
assertEquals(true, mMetadata.getBoolean(Metadata.SEEK_FORWARD_AVAILABLE));
}
// getLong
@SmallTest
public void testGetLong() throws Exception {
writeLongRecord(Metadata.DURATION, 1L);
adjustSize();
assertParse();
assertEquals(1L, mMetadata.getLong(Metadata.DURATION));
}
// getDouble
@SmallTest
public void testGetDouble() throws Exception {
writeDoubleRecord(Metadata.VIDEO_FRAME_RATE, 29.97);
adjustSize();
assertParse();
assertEquals(29.97, mMetadata.getDouble(Metadata.VIDEO_FRAME_RATE));
}
// getByteArray
@SmallTest
public void testGetByteArray() throws Exception {
byte data[] = new byte[]{1,2,3,4,5};
writeByteArrayRecord(Metadata.ALBUM_ART, data);
adjustSize();
assertParse();
byte res[] = mMetadata.getByteArray(Metadata.ALBUM_ART);
for (int i = 0; i < data.length; ++i) {
assertEquals(data[i], res[i]);
}
}
// getDate
@SmallTest
public void testGetDate() throws Exception {
writeDateRecord(Metadata.DATE, 0, "PST");
adjustSize();
assertParse();
assertEquals(new Date(0), mMetadata.getDate(Metadata.DATE));
}
// ----------------------------------------------------------------------
// HELPERS TO APPEND RECORDS
// ----------------------------------------------------------------------
// Insert a string record at the current position.
private void writeStringRecord(int metadataId, String val) {
final int start = mParcel.dataPosition();
mParcel.writeInt(-1); // Placeholder for the length
mParcel.writeInt(metadataId);
mParcel.writeInt(Metadata.STRING_VAL);
mParcel.writeString(val);
adjustSize(start);
}
// Insert an int record at the current position.
private void writeIntRecord(int metadataId, int val) {
final int start = mParcel.dataPosition();
mParcel.writeInt(-1); // Placeholder for the length
mParcel.writeInt(metadataId);
mParcel.writeInt(Metadata.INTEGER_VAL);
mParcel.writeInt(val);
adjustSize(start);
}
// Insert a boolean record at the current position.
private void writeBooleanRecord(int metadataId, boolean val) {
final int start = mParcel.dataPosition();
mParcel.writeInt(-1); // Placeholder for the length
mParcel.writeInt(metadataId);
mParcel.writeInt(Metadata.BOOLEAN_VAL);
mParcel.writeInt(val ? 1 : 0);
adjustSize(start);
}
// Insert a Long record at the current position.
private void writeLongRecord(int metadataId, long val) {
final int start = mParcel.dataPosition();
mParcel.writeInt(-1); // Placeholder for the length
mParcel.writeInt(metadataId);
mParcel.writeInt(Metadata.LONG_VAL);
mParcel.writeLong(val);
adjustSize(start);
}
// Insert a Double record at the current position.
private void writeDoubleRecord(int metadataId, double val) {
final int start = mParcel.dataPosition();
mParcel.writeInt(-1); // Placeholder for the length
mParcel.writeInt(metadataId);
mParcel.writeInt(Metadata.DOUBLE_VAL);
mParcel.writeDouble(val);
adjustSize(start);
}
// Insert a ByteArray record at the current position.
private void writeByteArrayRecord(int metadataId, byte[] val) {
final int start = mParcel.dataPosition();
mParcel.writeInt(-1); // Placeholder for the length
mParcel.writeInt(metadataId);
mParcel.writeInt(Metadata.BYTE_ARRAY_VAL);
mParcel.writeByteArray(val);
adjustSize(start);
}
// Insert a Date record at the current position.
private void writeDateRecord(int metadataId, long time, String tz) {
final int start = mParcel.dataPosition();
mParcel.writeInt(-1); // Placeholder for the length
mParcel.writeInt(metadataId);
mParcel.writeInt(Metadata.DATE_VAL);
mParcel.writeLong(time);
mParcel.writeString(tz);
adjustSize(start);
}
}
|
