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

/*
 * 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;
    }
}