Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes Ied6a13be,Ia4818f62,I660a4384

Browse Source 
* changes:
  StatsEvent unit tests
  Change visibility of members in StatsEvent
  Make StatsEvent.newBuilder() static
This commit is contained in:
Treehugger Robot
2020-01-10 22:24:13 +00:00
committed by Gerrit Code Review
parent 00fe08f5bf d2ed0f6729
commit c7483ff8bf
2 changed files with 650 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

223
core/java/android/util/StatsEvent.java
View File

@@ -43,6 +43,166 @@ import com.android.internal.annotations.VisibleForTesting;
* @hide
**/
public final class StatsEvent {
// Type Ids.
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_INT = 0x00;
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_LONG = 0x01;
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_STRING = 0x02;
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_LIST = 0x03;
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_FLOAT = 0x04;
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_BOOLEAN = 0x05;
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_BYTE_ARRAY = 0x06;
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_OBJECT = 0x07;
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_KEY_VALUE_PAIRS = 0x08;
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_ATTRIBUTION_CHAIN = 0x09;
/**
* @hide
**/
@VisibleForTesting
public static final byte TYPE_ERRORS = 0x0F;
// Error flags.
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_NO_TIMESTAMP = 0x1;
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_NO_ATOM_ID = 0x2;
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_OVERFLOW = 0x4;
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_ATTRIBUTION_CHAIN_TOO_LONG = 0x8;
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_TOO_MANY_KEY_VALUE_PAIRS = 0x10;
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_ANNOTATION_DOES_NOT_FOLLOW_FIELD = 0x20;
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_INVALID_ANNOTATION_ID = 0x40;
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_ANNOTATION_ID_TOO_LARGE = 0x80;
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_TOO_MANY_ANNOTATIONS = 0x100;
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_TOO_MANY_FIELDS = 0x200;
/**
* @hide
**/
@VisibleForTesting
public static final int ERROR_ATTRIBUTION_UIDS_TAGS_SIZES_NOT_EQUAL = 0x400;
// Size limits.
/**
* @hide
**/
@VisibleForTesting
public static final int MAX_ANNOTATION_COUNT = 15;
/**
* @hide
**/
@VisibleForTesting
public static final int MAX_ATTRIBUTION_NODES = 127;
/**
* @hide
**/
@VisibleForTesting
public static final int MAX_NUM_ELEMENTS = 127;
/**
* @hide
**/
@VisibleForTesting
public static final int MAX_KEY_VALUE_PAIRS = 127;
private static final int LOGGER_ENTRY_MAX_PAYLOAD = 4068;
// Max payload size is 4 bytes less as 4 bytes are reserved for statsEventTag.
@@ -63,24 +223,42 @@ public final class StatsEvent {
* Returns a new StatsEvent.Builder for building StatsEvent object.
**/
@NonNull
public StatsEvent.Builder newBuilder() {
public static StatsEvent.Builder newBuilder() {
return new StatsEvent.Builder(Buffer.obtain());
}
int getAtomId() {
/**
* Get the atom Id of the atom encoded in this StatsEvent object.
*
* @hide
**/
public int getAtomId() {
return mAtomId;
}
/**
* Get the byte array that contains the encoded payload that can be sent to statsd.
*
* @hide
**/
@NonNull
byte[] getBytes() {
public byte[] getBytes() {
return mBuffer.getBytes();
}
int getNumBytes() {
/**
* Get the number of bytes used to encode the StatsEvent payload.
*
* @hide
**/
public int getNumBytes() {
return mNumBytes;
}
void release() {
/**
* Recycle this StatsEvent object.
**/
public void release() {
mBuffer.release();
}
@@ -112,41 +290,8 @@ public final class StatsEvent {
* .addBooleanAnnotation(annotation1Id, true)
* .build();
* </pre>
* @hide
**/
public static final class Builder {
// Type Ids.
private static final byte TYPE_INT = 0x00;
private static final byte TYPE_LONG = 0x01;
private static final byte TYPE_STRING = 0x02;
private static final byte TYPE_LIST = 0x03;
private static final byte TYPE_FLOAT = 0x04;
private static final byte TYPE_BOOLEAN = 0x05;
private static final byte TYPE_BYTE_ARRAY = 0x06;
private static final byte TYPE_OBJECT = 0x07;
private static final byte TYPE_KEY_VALUE_PAIRS = 0x08;
private static final byte TYPE_ATTRIBUTION_CHAIN = 0x09;
private static final byte TYPE_ERRORS = 0x0F;
// Error flags.
private static final int ERROR_NO_TIMESTAMP = 0x1;
private static final int ERROR_NO_ATOM_ID = 0x2;
private static final int ERROR_OVERFLOW = 0x4;
private static final int ERROR_ATTRIBUTION_CHAIN_TOO_LONG = 0x8;
private static final int ERROR_TOO_MANY_KEY_VALUE_PAIRS = 0x10;
private static final int ERROR_ANNOTATION_DOES_NOT_FOLLOW_FIELD = 0x20;
private static final int ERROR_INVALID_ANNOTATION_ID = 0x40;
private static final int ERROR_ANNOTATION_ID_TOO_LARGE = 0x80;
private static final int ERROR_TOO_MANY_ANNOTATIONS = 0x100;
private static final int ERROR_TOO_MANY_FIELDS = 0x200;
private static final int ERROR_ATTRIBUTION_UIDS_TAGS_SIZES_NOT_EQUAL = 0x400;
// Size limits.
private static final int MAX_ANNOTATION_COUNT = 15;
private static final int MAX_ATTRIBUTION_NODES = 127;
private static final int MAX_NUM_ELEMENTS = 127;
private static final int MAX_KEY_VALUE_PAIRS = 127;
// Fixed positions.
private static final int POS_NUM_ELEMENTS = 1;
private static final int POS_TIMESTAMP_NS = POS_NUM_ELEMENTS + Byte.BYTES;
@@ -288,7 +433,7 @@ public final class StatsEvent {
* @param tags array of tags in the attribution nodes.
**/
@NonNull
public Builder writeAttributionNode(
public Builder writeAttributionChain(
@NonNull final int[] uids, @NonNull final String[] tags) {
final byte numUids = (byte) uids.length;
final byte numTags = (byte) tags.length;

466
core/tests/coretests/src/android/util/StatsEventTest.java Normal file
View File

@@ -0,0 +1,466 @@
/*
* Copyright (C) 2019 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;
import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static java.nio.charset.StandardCharsets.UTF_8;
import android.os.SystemClock;
import androidx.test.filters.SmallTest;
import androidx.test.runner.AndroidJUnit4;
import com.google.common.collect.Range;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
/**
* Internal tests for {@link StatsEvent}.
*/
@SmallTest
@RunWith(AndroidJUnit4.class)
public class StatsEventTest {
@Test
public void testNoFields() {
final long minTimestamp = SystemClock.elapsedRealtimeNanos();
final StatsEvent statsEvent = StatsEvent.newBuilder().build();
final long maxTimestamp = SystemClock.elapsedRealtimeNanos();
final int expectedAtomId = 0;
assertThat(statsEvent.getAtomId()).isEqualTo(expectedAtomId);
final ByteBuffer buffer =
ByteBuffer.wrap(statsEvent.getBytes()).order(ByteOrder.LITTLE_ENDIAN);
assertWithMessage("Root element in buffer is not TYPE_ERRORS")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_ERRORS);
assertWithMessage("Incorrect number of elements in root object")
.that(buffer.get()).isEqualTo(3);
assertWithMessage("First element is not timestamp")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_LONG);
assertWithMessage("Incorrect timestamp")
.that(buffer.getLong()).isIn(Range.closed(minTimestamp, maxTimestamp));
assertWithMessage("Second element is not atom id")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Incorrect atom id")
.that(buffer.getInt()).isEqualTo(expectedAtomId);
final int errorMask = buffer.getInt();
assertWithMessage("ERROR_NO_ATOM_ID should be the only error in the error mask")
.that(errorMask).isEqualTo(StatsEvent.ERROR_NO_ATOM_ID);
assertThat(statsEvent.getNumBytes()).isEqualTo(buffer.position());
statsEvent.release();
}
@Test
public void testIntBooleanIntInt() {
final int expectedAtomId = 109;
final int field1 = 1;
final boolean field2 = true;
final int field3 = 3;
final int field4 = 4;
final long minTimestamp = SystemClock.elapsedRealtimeNanos();
final StatsEvent statsEvent = StatsEvent.newBuilder()
.setAtomId(expectedAtomId)
.writeInt(field1)
.writeBoolean(field2)
.writeInt(field3)
.writeInt(field4)
.build();
final long maxTimestamp = SystemClock.elapsedRealtimeNanos();
assertThat(statsEvent.getAtomId()).isEqualTo(expectedAtomId);
final ByteBuffer buffer =
ByteBuffer.wrap(statsEvent.getBytes()).order(ByteOrder.LITTLE_ENDIAN);
assertWithMessage("Root element in buffer is not TYPE_OBJECT")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_OBJECT);
assertWithMessage("Incorrect number of elements in root object")
.that(buffer.get()).isEqualTo(6);
assertWithMessage("First element is not timestamp")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_LONG);
assertWithMessage("Incorrect timestamp")
.that(buffer.getLong()).isIn(Range.closed(minTimestamp, maxTimestamp));
assertWithMessage("Second element is not atom id")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Incorrect atom id")
.that(buffer.getInt()).isEqualTo(expectedAtomId);
assertWithMessage("First field is not Int")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Incorrect field 1")
.that(buffer.getInt()).isEqualTo(field1);
assertWithMessage("Second field is not Boolean")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_BOOLEAN);
assertWithMessage("Incorrect field 2")
.that(buffer.get()).isEqualTo(1);
assertWithMessage("Third field is not Int")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Incorrect field 3")
.that(buffer.getInt()).isEqualTo(field3);
assertWithMessage("Fourth field is not Int")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Incorrect field 4")
.that(buffer.getInt()).isEqualTo(field4);
assertThat(statsEvent.getNumBytes()).isEqualTo(buffer.position());
statsEvent.release();
}
@Test
public void testStringFloatByteArray() {
final int expectedAtomId = 109;
final String field1 = "Str 1";
final float field2 = 9.334f;
final byte[] field3 = new byte[] { 56, 23, 89, -120 };
final long minTimestamp = SystemClock.elapsedRealtimeNanos();
final StatsEvent statsEvent = StatsEvent.newBuilder()
.setAtomId(expectedAtomId)
.writeString(field1)
.writeFloat(field2)
.writeByteArray(field3)
.build();
final long maxTimestamp = SystemClock.elapsedRealtimeNanos();
assertThat(statsEvent.getAtomId()).isEqualTo(expectedAtomId);
final ByteBuffer buffer =
ByteBuffer.wrap(statsEvent.getBytes()).order(ByteOrder.LITTLE_ENDIAN);
assertWithMessage("Root element in buffer is not TYPE_OBJECT")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_OBJECT);
assertWithMessage("Incorrect number of elements in root object")
.that(buffer.get()).isEqualTo(5);
assertWithMessage("First element is not timestamp")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_LONG);
assertWithMessage("Incorrect timestamp")
.that(buffer.getLong()).isIn(Range.closed(minTimestamp, maxTimestamp));
assertWithMessage("Second element is not atom id")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Incorrect atom id")
.that(buffer.getInt()).isEqualTo(expectedAtomId);
assertWithMessage("First field is not String")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_STRING);
final String field1Actual = getStringFromByteBuffer(buffer);
assertWithMessage("Incorrect field 1")
.that(field1Actual).isEqualTo(field1);
assertWithMessage("Second field is not Float")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_FLOAT);
assertWithMessage("Incorrect field 2")
.that(buffer.getFloat()).isEqualTo(field2);
assertWithMessage("Third field is not byte array")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_BYTE_ARRAY);
final byte[] field3Actual = getByteArrayFromByteBuffer(buffer);
assertWithMessage("Incorrect field 3")
.that(field3Actual).isEqualTo(field3);
assertThat(statsEvent.getNumBytes()).isEqualTo(buffer.position());
statsEvent.release();
}
@Test
public void testAttributionChainLong() {
final int expectedAtomId = 109;
final int[] uids = new int[] { 1, 2, 3, 4, 5 };
final String[] tags = new String[] { "1", "2", "3", "4", "5" };
final long field2 = -230909823L;
final long minTimestamp = SystemClock.elapsedRealtimeNanos();
final StatsEvent statsEvent = StatsEvent.newBuilder()
.setAtomId(expectedAtomId)
.writeAttributionChain(uids, tags)
.writeLong(field2)
.build();
final long maxTimestamp = SystemClock.elapsedRealtimeNanos();
assertThat(statsEvent.getAtomId()).isEqualTo(expectedAtomId);
final ByteBuffer buffer =
ByteBuffer.wrap(statsEvent.getBytes()).order(ByteOrder.LITTLE_ENDIAN);
assertWithMessage("Root element in buffer is not TYPE_OBJECT")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_OBJECT);
assertWithMessage("Incorrect number of elements in root object")
.that(buffer.get()).isEqualTo(4);
assertWithMessage("First element is not timestamp")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_LONG);
assertWithMessage("Incorrect timestamp")
.that(buffer.getLong()).isIn(Range.closed(minTimestamp, maxTimestamp));
assertWithMessage("Second element is not atom id")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Incorrect atom id")
.that(buffer.getInt()).isEqualTo(expectedAtomId);
assertWithMessage("First field is not Attribution Chain")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_ATTRIBUTION_CHAIN);
assertWithMessage("Incorrect number of attribution nodes")
.that(buffer.get()).isEqualTo((byte) uids.length);
for (int i = 0; i < tags.length; i++) {
assertWithMessage("Incorrect uid in Attribution Chain")
.that(buffer.getInt()).isEqualTo(uids[i]);
final String tag = getStringFromByteBuffer(buffer);
assertWithMessage("Incorrect tag in Attribution Chain")
.that(tag).isEqualTo(tags[i]);
}
assertWithMessage("Second field is not Long")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_LONG);
assertWithMessage("Incorrect field 2")
.that(buffer.getLong()).isEqualTo(field2);
assertThat(statsEvent.getNumBytes()).isEqualTo(buffer.position());
statsEvent.release();
}
@Test
public void testKeyValuePairs() {
final int expectedAtomId = 109;
final SparseIntArray intMap = new SparseIntArray();
final SparseLongArray longMap = new SparseLongArray();
final SparseArray<String> stringMap = new SparseArray<>();
final SparseArray<Float> floatMap = new SparseArray<>();
intMap.put(1, -1);
intMap.put(2, -2);
stringMap.put(3, "abc");
stringMap.put(4, "2h");
floatMap.put(9, -234.344f);
final long minTimestamp = SystemClock.elapsedRealtimeNanos();
final StatsEvent statsEvent = StatsEvent.newBuilder()
.setAtomId(expectedAtomId)
.writeKeyValuePairs(intMap, longMap, stringMap, floatMap)
.build();
final long maxTimestamp = SystemClock.elapsedRealtimeNanos();
assertThat(statsEvent.getAtomId()).isEqualTo(expectedAtomId);
final ByteBuffer buffer =
ByteBuffer.wrap(statsEvent.getBytes()).order(ByteOrder.LITTLE_ENDIAN);
assertWithMessage("Root element in buffer is not TYPE_OBJECT")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_OBJECT);
assertWithMessage("Incorrect number of elements in root object")
.that(buffer.get()).isEqualTo(3);
assertWithMessage("First element is not timestamp")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_LONG);
assertWithMessage("Incorrect timestamp")
.that(buffer.getLong()).isIn(Range.closed(minTimestamp, maxTimestamp));
assertWithMessage("Second element is not atom id")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Incorrect atom id")
.that(buffer.getInt()).isEqualTo(expectedAtomId);
assertWithMessage("First field is not KeyValuePairs")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_KEY_VALUE_PAIRS);
assertWithMessage("Incorrect number of key value pairs")
.that(buffer.get()).isEqualTo(
(byte) (intMap.size() + longMap.size() + stringMap.size()
+ floatMap.size()));
for (int i = 0; i < intMap.size(); i++) {
assertWithMessage("Incorrect key in intMap")
.that(buffer.getInt()).isEqualTo(intMap.keyAt(i));
assertWithMessage("The type id of the value should be TYPE_INT in intMap")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Incorrect value in intMap")
.that(buffer.getInt()).isEqualTo(intMap.valueAt(i));
}
for (int i = 0; i < longMap.size(); i++) {
assertWithMessage("Incorrect key in longMap")
.that(buffer.getInt()).isEqualTo(longMap.keyAt(i));
assertWithMessage("The type id of the value should be TYPE_LONG in longMap")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_LONG);
assertWithMessage("Incorrect value in longMap")
.that(buffer.getLong()).isEqualTo(longMap.valueAt(i));
}
for (int i = 0; i < stringMap.size(); i++) {
assertWithMessage("Incorrect key in stringMap")
.that(buffer.getInt()).isEqualTo(stringMap.keyAt(i));
assertWithMessage("The type id of the value should be TYPE_STRING in stringMap")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_STRING);
final String value = getStringFromByteBuffer(buffer);
assertWithMessage("Incorrect value in stringMap")
.that(value).isEqualTo(stringMap.valueAt(i));
}
for (int i = 0; i < floatMap.size(); i++) {
assertWithMessage("Incorrect key in floatMap")
.that(buffer.getInt()).isEqualTo(floatMap.keyAt(i));
assertWithMessage("The type id of the value should be TYPE_FLOAT in floatMap")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_FLOAT);
assertWithMessage("Incorrect value in floatMap")
.that(buffer.getFloat()).isEqualTo(floatMap.valueAt(i));
}
assertThat(statsEvent.getNumBytes()).isEqualTo(buffer.position());
statsEvent.release();
}
@Test
public void testSingleAnnotations() {
final int expectedAtomId = 109;
final int field1 = 1;
final byte field1AnnotationId = 45;
final boolean field1AnnotationValue = false;
final boolean field2 = true;
final byte field2AnnotationId = 1;
final int field2AnnotationValue = 23;
final long minTimestamp = SystemClock.elapsedRealtimeNanos();
final StatsEvent statsEvent = StatsEvent.newBuilder()
.setAtomId(expectedAtomId)
.writeInt(field1)
.addBooleanAnnotation(field1AnnotationId, field1AnnotationValue)
.writeBoolean(field2)
.addIntAnnotation(field2AnnotationId, field2AnnotationValue)
.build();
final long maxTimestamp = SystemClock.elapsedRealtimeNanos();
assertThat(statsEvent.getAtomId()).isEqualTo(expectedAtomId);
final ByteBuffer buffer =
ByteBuffer.wrap(statsEvent.getBytes()).order(ByteOrder.LITTLE_ENDIAN);
assertWithMessage("Root element in buffer is not TYPE_OBJECT")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_OBJECT);
assertWithMessage("Incorrect number of elements in root object")
.that(buffer.get()).isEqualTo(4);
assertWithMessage("First element is not timestamp")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_LONG);
assertWithMessage("Incorrect timestamp")
.that(buffer.getLong()).isIn(Range.closed(minTimestamp, maxTimestamp));
assertWithMessage("Second element is not atom id")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Incorrect atom id")
.that(buffer.getInt()).isEqualTo(expectedAtomId);
final byte field1Header = buffer.get();
final int field1AnnotationValueCount = field1Header >> 4;
final byte field1Type = (byte) (field1Header & 0x0F);
assertWithMessage("First field is not Int")
.that(field1Type).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("First field annotation count is wrong")
.that(field1AnnotationValueCount).isEqualTo(1);
assertWithMessage("Incorrect field 1")
.that(buffer.getInt()).isEqualTo(field1);
assertWithMessage("First field's annotation id is wrong")
.that(buffer.get()).isEqualTo(field1AnnotationId);
assertWithMessage("First field's annotation type is wrong")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_BOOLEAN);
assertWithMessage("First field's annotation value is wrong")
.that(buffer.get()).isEqualTo(field1AnnotationValue ? 1 : 0);
final byte field2Header = buffer.get();
final int field2AnnotationValueCount = field2Header >> 4;
final byte field2Type = (byte) (field2Header & 0x0F);
assertWithMessage("Second field is not boolean")
.that(field2Type).isEqualTo(StatsEvent.TYPE_BOOLEAN);
assertWithMessage("Second field annotation count is wrong")
.that(field2AnnotationValueCount).isEqualTo(1);
assertWithMessage("Incorrect field 2")
.that(buffer.get()).isEqualTo(field2 ? 1 : 0);
assertWithMessage("Second field's annotation id is wrong")
.that(buffer.get()).isEqualTo(field2AnnotationId);
assertWithMessage("Second field's annotation type is wrong")
.that(buffer.get()).isEqualTo(StatsEvent.TYPE_INT);
assertWithMessage("Second field's annotation value is wrong")
.that(buffer.getInt()).isEqualTo(field2AnnotationValue);
assertThat(statsEvent.getNumBytes()).isEqualTo(buffer.position());
statsEvent.release();
}
private static byte[] getByteArrayFromByteBuffer(final ByteBuffer buffer) {
final int numBytes = buffer.getInt();
byte[] bytes = new byte[numBytes];
buffer.get(bytes);
return bytes;
}
private static String getStringFromByteBuffer(final ByteBuffer buffer) {
final byte[] bytes = getByteArrayFromByteBuffer(buffer);
return new String(bytes, UTF_8);
}
}