private <T> T readValue(T pastEndValue, Class<T> clazz, boolean allowNull) {
    """
	Reads the next value in the byte buffer of a specified type.
	
	@param pastEndValue value to return when reading past the end of the buffer
	@param clazz this is the type that is being read, but not checked in this method
	@param allowNull whether null values are permitted
    """
      if (dataPosition >= dataSize) {
        // Normally, reading past the end is permitted, and returns the default values.  However,
        // writing to a parcel then reading without setting the position back to 0 is an incredibly
        // common error to make in tests, and should never really happen in production code, so
        // this shadow will fail in this condition.
        if (failNextReadIfPastEnd) {
          throw new UnreliableBehaviorError(
              "Did you forget to setDataPosition(0) before reading the parcel?");
        }
        return pastEndValue;
      }
      int startPosition = dataPosition;
      FakeEncodedItem item = readNextItem(clazz);
      if (item == null) {
        return pastEndValue;
      } else if (item.value == null && allowNull) {
        return null;
      } else if (clazz.isInstance(item.value)) {
        return clazz.cast(item.value);
      } else {
        // Numerous existing tests rely on ShadowParcel throwing RuntimeException and catching
        // them.  Many of these tests are trying to test what happens when an invalid Parcel is
        // provided.  However, Android has no concept of an "invalid parcel" because Parcel will
        // happily return garbage if you ask for it.  The only runtime exceptions are thrown on
        // array length mismatches, or higher-level APIs like Parcelable (which has its own safety
        // checks).  Tests trying to test error-handling behavior should instead craft a Parcel
        // that specifically triggers a BadParcelableException.
        throw new RuntimeException(
            new UnreliableBehaviorError(
                clazz, startPosition, item, "and it is non-portable to reinterpret it"));
      }
    }
private <T> T readValue(T pastEndValue, Class<T> clazz, boolean allowNull) {
      if (dataPosition >= dataSize) {
        // Normally, reading past the end is permitted, and returns the default values.  However,
        // writing to a parcel then reading without setting the position back to 0 is an incredibly
        // common error to make in tests, and should never really happen in production code, so
        // this shadow will fail in this condition.
        if (failNextReadIfPastEnd) {
          throw new UnreliableBehaviorError(
              "Did you forget to setDataPosition(0) before reading the parcel?");
        }
        return pastEndValue;
      }
      int startPosition = dataPosition;
      FakeEncodedItem item = readNextItem(clazz);
      if (item == null) {
        return pastEndValue;
      } else if (item.value == null && allowNull) {
        return null;
      } else if (clazz.isInstance(item.value)) {
        return clazz.cast(item.value);
      } else {
        // Numerous existing tests rely on ShadowParcel throwing RuntimeException and catching
        // them.  Many of these tests are trying to test what happens when an invalid Parcel is
        // provided.  However, Android has no concept of an "invalid parcel" because Parcel will
        // happily return garbage if you ask for it.  The only runtime exceptions are thrown on
        // array length mismatches, or higher-level APIs like Parcelable (which has its own safety
        // checks).  Tests trying to test error-handling behavior should instead craft a Parcel
        // that specifically triggers a BadParcelableException.
        throw new RuntimeException(
            new UnreliableBehaviorError(
                clazz, startPosition, item, "and it is non-portable to reinterpret it"));
      }
    }
private < T > T readValue ( T pastEndValue , Class < T > clazz , boolean allowNull ) { if ( dataPosition >= dataSize ) { // Normally, reading past the end is permitted, and returns the default values.  However, // writing to a parcel then reading without setting the position back to 0 is an incredibly // common error to make in tests, and should never really happen in production code, so // this shadow will fail in this condition. if ( failNextReadIfPastEnd ) { throw new UnreliableBehaviorError ( "Did you forget to setDataPosition(0) before reading the parcel?" ) ; } return pastEndValue ; } int startPosition = dataPosition ; FakeEncodedItem item = readNextItem ( clazz ) ; if ( item == null ) { return pastEndValue ; } else if ( item . value == null && allowNull ) { return null ; } else if ( clazz . isInstance ( item . value ) ) { return clazz . cast ( item . value ) ; } else { // Numerous existing tests rely on ShadowParcel throwing RuntimeException and catching // them.  Many of these tests are trying to test what happens when an invalid Parcel is // provided.  However, Android has no concept of an "invalid parcel" because Parcel will // happily return garbage if you ask for it.  The only runtime exceptions are thrown on // array length mismatches, or higher-level APIs like Parcelable (which has its own safety // checks).  Tests trying to test error-handling behavior should instead craft a Parcel // that specifically triggers a BadParcelableException. throw new RuntimeException ( new UnreliableBehaviorError ( clazz , startPosition , item , "and it is non-portable to reinterpret it" ) ) ; } }
Reads the next value in the byte buffer of a specified type.

@param pastEndValue value to return when reading past the end of the buffer
@param clazz this is the type that is being read, but not checked in this method
@param allowNull whether null values are permitted
Reads the next value in the byte buffer of a specified type .