blob: 3afc971825b5a5f11a536980929916ee0dbb8592 [file] [log] [blame]
/*
* 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 android.util.proto.cts;
import android.util.proto.ProtoOutputStream;
import android.util.proto.cts.nano.Test;
import com.google.protobuf.nano.MessageNano;
import junit.framework.TestCase;
import org.junit.Assert;
/**
* Test the uint32 methods on the ProtoOutputStream class.
*/
public class ProtoOutputStreamUInt32Test extends TestCase {
// ----------------------------------------------------------------------
// writeUInt32
// ----------------------------------------------------------------------
/**
* Test writeUInt32.
*/
public void testWrite() throws Exception {
testWrite(0);
testWrite(1);
testWrite(5);
}
/**
* Implementation of testWrite with a given chunkSize.
*/
public void testWrite(int chunkSize) throws Exception {
final ProtoOutputStream po = new ProtoOutputStream(chunkSize);
final long fieldFlags = ProtoOutputStream.FIELD_COUNT_SINGLE | ProtoOutputStream.FIELD_TYPE_UINT32;
po.writeUInt32(ProtoOutputStream.makeFieldId(1, fieldFlags), 0);
po.writeUInt32(ProtoOutputStream.makeFieldId(2, fieldFlags), 1);
po.writeUInt32(ProtoOutputStream.makeFieldId(3, fieldFlags), -1);
po.writeUInt32(ProtoOutputStream.makeFieldId(4, fieldFlags), Integer.MIN_VALUE);
po.writeUInt32(ProtoOutputStream.makeFieldId(5, fieldFlags), Integer.MAX_VALUE);
final byte[] result = po.getBytes();
Assert.assertArrayEquals(new byte[] {
// 1 -> 0 - default value, not written
// 2 -> 1
(byte)0x10,
(byte)0x01,
// 3 -> -1
(byte)0x18,
(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x0f,
// 4 -> MIN_VALUE
(byte)0x20,
(byte)0x80, (byte)0x80, (byte)0x80, (byte)0x80, (byte)0x08,
// 5 -> MAX_VALUE
(byte)0x28,
(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x07,
}, result);
}
/**
* Test that writing a with ProtoOutputStream matches, and can be read by standard proto.
*/
public void testWriteCompat() throws Exception {
testWriteCompat(0);
testWriteCompat(1);
testWriteCompat(-1);
testWriteCompat(Integer.MIN_VALUE);
testWriteCompat(Integer.MAX_VALUE);
}
/**
* Implementation of testWriteCompat with a given value.
*/
public void testWriteCompat(int val) throws Exception {
final int fieldId = 50;
final long fieldFlags = ProtoOutputStream.FIELD_COUNT_SINGLE | ProtoOutputStream.FIELD_TYPE_UINT32;
final Test.All all = new Test.All();
final ProtoOutputStream po = new ProtoOutputStream(0);
all.uint32Field = val;
po.writeUInt32(ProtoOutputStream.makeFieldId(fieldId, fieldFlags), val);
final byte[] result = po.getBytes();
final byte[] expected = MessageNano.toByteArray(all);
Assert.assertArrayEquals(expected, result);
final Test.All readback = Test.All.parseFrom(result);
assertEquals(val, readback.uint32Field);
}
// ----------------------------------------------------------------------
// writeRepeatedUInt32
// ----------------------------------------------------------------------
/**
* Test writeUInt32.
*/
public void testRepeated() throws Exception {
testRepeated(0);
testRepeated(1);
testRepeated(5);
}
/**
* Implementation of testRepeated with a given chunkSize.
*/
public void testRepeated(int chunkSize) throws Exception {
final ProtoOutputStream po = new ProtoOutputStream(chunkSize);
final long fieldFlags = ProtoOutputStream.FIELD_COUNT_REPEATED | ProtoOutputStream.FIELD_TYPE_UINT32;
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(1, fieldFlags), 0);
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(2, fieldFlags), 1);
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(3, fieldFlags), -1);
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(4, fieldFlags), Integer.MIN_VALUE);
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(5, fieldFlags), Integer.MAX_VALUE);
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(1, fieldFlags), 0);
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(2, fieldFlags), 1);
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(3, fieldFlags), -1);
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(4, fieldFlags), Integer.MIN_VALUE);
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(5, fieldFlags), Integer.MAX_VALUE);
final byte[] result = po.getBytes();
Assert.assertArrayEquals(new byte[] {
// 1 -> 0 - default value, written when repeated
(byte)0x08,
(byte)0x00,
// 2 -> 1
(byte)0x10,
(byte)0x01,
// 3 -> -1
(byte)0x18,
(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x0f,
// 4 -> MIN_VALUE
(byte)0x20,
(byte)0x80, (byte)0x80, (byte)0x80, (byte)0x80, (byte)0x08,
// 5 -> MAX_VALUE
(byte)0x28,
(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x07,
// 1 -> 0 - default value, written when repeated
(byte)0x08,
(byte)0x00,
// 2 -> 1
(byte)0x10,
(byte)0x01,
// 3 -> -1
(byte)0x18,
(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x0f,
// 4 -> MIN_VALUE
(byte)0x20,
(byte)0x80, (byte)0x80, (byte)0x80, (byte)0x80, (byte)0x08,
// 5 -> MAX_VALUE
(byte)0x28,
(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x07,
}, result);
}
/**
* Test that writing a with ProtoOutputStream matches, and can be read by standard proto.
*/
public void testRepeatedCompat() throws Exception {
testRepeatedCompat(new int[0]);
testRepeatedCompat(new int[] { 0, 1, -1, Integer.MIN_VALUE, Integer.MAX_VALUE });
}
/**
* Implementation of testRepeatedCompat with a given value.
*/
public void testRepeatedCompat(int[] val) throws Exception {
final int fieldId = 51;
final long fieldFlags = ProtoOutputStream.FIELD_COUNT_REPEATED | ProtoOutputStream.FIELD_TYPE_UINT32;
final Test.All all = new Test.All();
final ProtoOutputStream po = new ProtoOutputStream(0);
all.uint32FieldRepeated = val;
for (int i=0; i<val.length; i++) {
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(fieldId, fieldFlags), val[i]);
}
final byte[] result = po.getBytes();
final byte[] expected = MessageNano.toByteArray(all);
Assert.assertArrayEquals(expected, result);
final Test.All readback = Test.All.parseFrom(result);
assertNotNull(readback.uint32FieldRepeated);
assertEquals(val.length, readback.uint32FieldRepeated.length);
for (int i=0; i<val.length; i++) {
assertEquals(val[i], readback.uint32FieldRepeated[i]);
}
}
// ----------------------------------------------------------------------
// writePackedUInt32
// ----------------------------------------------------------------------
/**
* Test writeUInt32.
*/
public void testPacked() throws Exception {
testPacked(0);
testPacked(1);
testPacked(5);
}
/**
* Create an array of the val, and write it.
*/
private void writePackedUInt32(ProtoOutputStream po, int fieldId, int val) {
final long fieldFlags = ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_UINT32;
po.writePackedUInt32(ProtoOutputStream.makeFieldId(fieldId, fieldFlags), new int[] { val, val });
}
/**
* Implementation of testPacked with a given chunkSize.
*/
public void testPacked(int chunkSize) throws Exception {
final ProtoOutputStream po = new ProtoOutputStream(chunkSize);
final long fieldFlags = ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_UINT32;
po.writePackedUInt32(ProtoOutputStream.makeFieldId(1000, fieldFlags), null);
po.writePackedUInt32(ProtoOutputStream.makeFieldId(1001, fieldFlags), new int[0]);
writePackedUInt32(po, 1, 0);
writePackedUInt32(po, 2, 1);
writePackedUInt32(po, 3, -1);
writePackedUInt32(po, 4, Integer.MIN_VALUE);
writePackedUInt32(po, 5, Integer.MAX_VALUE);
final byte[] result = po.getBytes();
Assert.assertArrayEquals(new byte[] {
// 1 -> 0 - default value, written when repeated
(byte)0x0a,
(byte)0x02,
(byte)0x00,
(byte)0x00,
// 2 -> 1
(byte)0x12,
(byte)0x02,
(byte)0x01,
(byte)0x01,
// 3 -> -1
(byte)0x1a,
(byte)0x0a,
(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x0f,
(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x0f,
// 4 -> MIN_VALUE
(byte)0x22,
(byte)0x0a,
(byte)0x80, (byte)0x80, (byte)0x80, (byte)0x80, (byte)0x08,
(byte)0x80, (byte)0x80, (byte)0x80, (byte)0x80, (byte)0x08,
// 5 -> MAX_VALUE
(byte)0x2a,
(byte)0x0a,
(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x07,
(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0x07,
}, result);
}
/**
* Test that writing a with ProtoOutputStream matches, and can be read by standard proto.
*/
public void testPackedCompat() throws Exception {
testPackedCompat(new int[] {});
testPackedCompat(new int[] { 0, 1, -1, Integer.MIN_VALUE, Integer.MAX_VALUE });
}
/**
* Implementation of testPackedUInt32Compat with a given value.
*/
public void testPackedCompat(int[] val) throws Exception {
final int fieldId = 52;
final long fieldFlags = ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_UINT32;
final Test.All all = new Test.All();
final ProtoOutputStream po = new ProtoOutputStream(0);
all.uint32FieldPacked = val;
po.writePackedUInt32(ProtoOutputStream.makeFieldId(fieldId, fieldFlags), val);
final byte[] result = po.getBytes();
final byte[] expected = MessageNano.toByteArray(all);
Assert.assertArrayEquals(expected, result);
final Test.All readback = Test.All.parseFrom(result);
Assert.assertArrayEquals(val, readback.uint32FieldPacked);
}
/**
* Test that if you pass in the wrong type of fieldId, it throws.
*/
public void testBadFieldIds() {
// Single
// Good Count / Bad Type
try {
final ProtoOutputStream po = new ProtoOutputStream();
po.writeUInt32(ProtoOutputStream.makeFieldId(1,
ProtoOutputStream.FIELD_COUNT_SINGLE | ProtoOutputStream.FIELD_TYPE_DOUBLE), 0);
} catch (IllegalArgumentException ex) {
// good
}
// Bad Count / Good Type
try {
final ProtoOutputStream po = new ProtoOutputStream();
po.writeUInt32(ProtoOutputStream.makeFieldId(1,
ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_UINT32), 0);
} catch (IllegalArgumentException ex) {
// good
}
// Repeated
// Good Count / Bad Type
try {
final ProtoOutputStream po = new ProtoOutputStream();
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(1,
ProtoOutputStream.FIELD_COUNT_REPEATED | ProtoOutputStream.FIELD_TYPE_DOUBLE), 0);
} catch (IllegalArgumentException ex) {
// good
}
// Bad Count / Good Type
try {
final ProtoOutputStream po = new ProtoOutputStream();
po.writeRepeatedUInt32(ProtoOutputStream.makeFieldId(1,
ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_UINT32), 0);
} catch (IllegalArgumentException ex) {
// good
}
// Packed
// Good Count / Bad Type
try {
final ProtoOutputStream po = new ProtoOutputStream();
po.writePackedUInt32(ProtoOutputStream.makeFieldId(1,
ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_DOUBLE),
new int[0]);
} catch (IllegalArgumentException ex) {
// good
}
// Bad Count / Good Type
try {
final ProtoOutputStream po = new ProtoOutputStream();
po.writePackedUInt32(ProtoOutputStream.makeFieldId(1,
ProtoOutputStream.FIELD_COUNT_SINGLE | ProtoOutputStream.FIELD_TYPE_UINT32),
new int[0]);
} catch (IllegalArgumentException ex) {
// good
}
}
}