Annotate Parcel param/return reference types. (b1f474c0) · Commits · e / os / android_frameworks_base

core/java/android/os/Parcel.java

+146 −98

File changed.

Preview size limit exceeded, changes collapsed.

core/java/android/text/TextUtils.java

+2 −1

Original line number	Diff line number	Diff line
		@@ -676,7 +676,8 @@ public class TextUtils {
		* Flatten a CharSequence and whatever styles can be copied across processes
		* into the parcel.
		*/
		public static void writeToParcel(CharSequence cs, Parcel p, int parcelableFlags) {
		public static void writeToParcel(@Nullable CharSequence cs, @NonNull Parcel p,
		int parcelableFlags) {
		if (cs instanceof Spanned) {
		p.writeInt(0);
		p.writeString(cs.toString());

core/tests/coretests/src/android/os/ParcelNullabilityTest.java

0 → 100644

+391 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.os;

		import static org.junit.Assert.assertNull;
		import static org.junit.Assert.assertTrue;
		import static org.junit.Assert.fail;

		import android.support.test.runner.AndroidJUnit4;
		import android.test.suitebuilder.annotation.SmallTest;
		import android.util.ArrayMap;

		import org.junit.Test;
		import org.junit.runner.RunWith;

		import java.util.ArrayList;
		import java.util.HashMap;
		import java.util.List;
		import java.util.Map;

		@SmallTest
		@RunWith(AndroidJUnit4.class)
		public final class ParcelNullabilityTest {
		@Test
		public void nullByteArray() {
		Parcel p = Parcel.obtain();
		p.writeByteArray(null);

		assertNull(throughBytes(p).createByteArray());
		}

		@Test
		public void nullBlob() {
		Parcel p = Parcel.obtain();
		p.writeBlob(null);

		assertNull(throughBytes(p).readBlob());
		}

		@Test
		public void nullString() {
		Parcel p = Parcel.obtain();
		p.writeString(null);

		assertNull(throughBytes(p).readString());
		}

		@Test
		public void nullCharSequence() {
		Parcel p = Parcel.obtain();
		p.writeCharSequence(null);

		assertNull(throughBytes(p).readCharSequence());
		}

		@Test
		public void nullStrongBinder() {
		Parcel p = Parcel.obtain();
		p.writeStrongBinder(null);

		assertNull(throughBytes(p).readStrongBinder());
		}

		@Test
		public void nullStringInterface() {
		Parcel p = Parcel.obtain();
		p.writeStrongInterface(null);

		assertNull(throughBytes(p).readStrongBinder());
		}

		@Test
		public void nullFileDescriptor() {
		Parcel p = Parcel.obtain();
		try {
		p.writeFileDescriptor(null);
		fail();
		} catch (RuntimeException expected) {
		}
		}

		@Test
		public void nullRawFileDescriptor() {
		Parcel p = Parcel.obtain();
		try {
		p.writeRawFileDescriptor(null);
		fail();
		} catch (RuntimeException expected) {
		}
		}

		@Test
		public void nullRawFileDescriptorArray() {
		Parcel p = Parcel.obtain();
		p.writeRawFileDescriptorArray(null);

		assertNull(throughBytes(p).createRawFileDescriptorArray());
		}

		@Test
		public void nullMap() {
		Parcel p = Parcel.obtain();
		p.writeMap(null);

		Map<Object, Object> map = new HashMap<>();
		throughBytes(p).readMap(map, null);
		assertTrue(map.isEmpty());
		}

		@Test
		public void nullArrayMap() {
		Parcel p = Parcel.obtain();
		p.writeArrayMap(null);

		ArrayMap<Object, Object> map = new ArrayMap<>();
		throughBytes(p).readArrayMap(map, null);
		assertTrue(map.isEmpty());
		}

		@Test
		public void nullArraySet() {
		Parcel p = Parcel.obtain();
		p.writeArraySet(null);

		assertNull(throughBytes(p).readArraySet(null));
		}

		@Test
		public void nullBundle() {
		Parcel p = Parcel.obtain();
		p.writeBundle(null);

		assertNull(throughBytes(p).readBundle());
		}

		@Test
		public void nullPersistableBundle() {
		Parcel p = Parcel.obtain();
		p.writePersistableBundle(null);

		assertNull(throughBytes(p).readPersistableBundle());
		}

		@Test
		public void nullSize() {
		Parcel p = Parcel.obtain();
		try {
		p.writeSize(null);
		fail();
		} catch (RuntimeException expected) {
		}
		}

		@Test
		public void nullSizeF() {
		Parcel p = Parcel.obtain();
		try {
		p.writeSizeF(null);
		fail();
		} catch (RuntimeException expected) {
		}
		}

		@Test
		public void nullList() {
		Parcel p = Parcel.obtain();
		p.writeList(null);

		List<Object> map = new ArrayList<>();
		throughBytes(p).readList(map, null);
		assertTrue(map.isEmpty());
		}

		@Test
		public void nullArray() {
		Parcel p = Parcel.obtain();
		p.writeArray(null);

		assertNull(throughBytes(p).readArray(null));
		}

		@Test
		public void nullSparseArray() {
		Parcel p = Parcel.obtain();
		p.writeSparseArray(null);

		assertNull(throughBytes(p).readSparseArray(null));
		}

		@Test
		public void nullSparseBooleanArray() {
		Parcel p = Parcel.obtain();
		p.writeSparseBooleanArray(null);

		assertNull(throughBytes(p).readSparseBooleanArray());
		}

		@Test
		public void nullSparseIntArray() {
		Parcel p = Parcel.obtain();
		p.writeSparseIntArray(null);

		assertNull(throughBytes(p).readSparseIntArray());
		}

		@Test
		public void nullBooleanArray() {
		Parcel p = Parcel.obtain();
		p.writeBooleanArray(null);

		assertNull(throughBytes(p).createBooleanArray());
		}

		@Test
		public void nullCharArray() {
		Parcel p = Parcel.obtain();
		p.writeCharArray(null);

		assertNull(throughBytes(p).createCharArray());
		}

		@Test
		public void nullIntArray() {
		Parcel p = Parcel.obtain();
		p.writeIntArray(null);

		assertNull(throughBytes(p).createIntArray());
		}

		@Test
		public void nullLongArray() {
		Parcel p = Parcel.obtain();
		p.writeLongArray(null);

		assertNull(throughBytes(p).createLongArray());
		}

		@Test
		public void nullFloatArray() {
		Parcel p = Parcel.obtain();
		p.writeFloatArray(null);

		assertNull(throughBytes(p).createFloatArray());
		}

		@Test
		public void nullDoubleArray() {
		Parcel p = Parcel.obtain();
		p.writeDoubleArray(null);

		assertNull(throughBytes(p).createDoubleArray());
		}

		@Test
		public void nullStringArray() {
		Parcel p = Parcel.obtain();
		p.writeStringArray(null);

		assertNull(throughBytes(p).createStringArray());
		}

		@Test
		public void nullCharSequenceArray() {
		Parcel p = Parcel.obtain();
		p.writeCharSequenceArray(null);

		assertNull(throughBytes(p).readCharSequenceArray());
		}

		@Test
		public void nullCharSequenceList() {
		Parcel p = Parcel.obtain();
		p.writeCharSequenceList(null);

		assertNull(throughBytes(p).readCharSequenceList());
		}

		@Test
		public void nullBinderArray() {
		Parcel p = Parcel.obtain();
		p.writeBinderArray(null);

		assertNull(throughBytes(p).createBinderArray());
		}

		@Test
		public void nullTypedList() {
		Parcel p = Parcel.obtain();
		p.writeTypedList(null);

		assertNull(throughBytes(p).createTypedArrayList(null));
		}

		@Test
		public void nullStringList() {
		Parcel p = Parcel.obtain();
		p.writeStringList(null);

		assertNull(throughBytes(p).createStringArrayList());
		}

		@Test
		public void nullBinderList() {
		Parcel p = Parcel.obtain();
		p.writeBinderList(null);

		assertNull(throughBytes(p).createBinderArrayList());
		}

		@Test
		public void nullParcelableList() {
		Parcel p = Parcel.obtain();
		p.writeParcelableList(null, 0);

		List<Object> list = new ArrayList<>();
		throughBytes(p).readParcelableList(null, null);
		assertTrue(list.isEmpty());
		}

		@Test
		public void nullTypedArray() {
		Parcel p = Parcel.obtain();
		p.writeTypedArray(null, 0);

		assertNull(throughBytes(p).createTypedArray(null));
		}

		@Test
		public void nullTypedObject() {
		Parcel p = Parcel.obtain();
		p.writeTypedObject(null, 0);

		assertNull(throughBytes(p).readTypedObject(null));
		}

		@Test
		public void nullValue() {
		Parcel p = Parcel.obtain();
		p.writeValue(null);

		assertNull(throughBytes(p).readValue(null));
		}

		@Test
		public void nullParcelable() {
		Parcel p = Parcel.obtain();
		p.writeParcelable(null, 0);

		assertNull(throughBytes(p).readParcelable(null));
		}

		@Test
		public void nullSerializable() {
		Parcel p = Parcel.obtain();
		p.writeSerializable(null);

		assertNull(throughBytes(p).readSerializable());
		}

		@Test
		public void nullException() {
		Parcel p = Parcel.obtain();
		try {
		p.writeException(null);
		fail();
		} catch (RuntimeException expected) {
		}
		}

		private static Parcel throughBytes(Parcel p) {
		byte[] bytes = p.marshall();
		p = Parcel.obtain();
		p.unmarshall(bytes, 0, bytes.length);
		p.setDataPosition(0);
		return p;
		}
		}