robolectric/shadows/ParcelTest.java

package com.xtremelabs.robolectric.shadows;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

import android.accounts.Account;
import android.content.Intent;
import android.os.Bundle;
import android.os.Parcel;

import com.xtremelabs.robolectric.Robolectric;
import com.xtremelabs.robolectric.WithTestDefaultsRunner;

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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@RunWith(WithTestDefaultsRunner.class)
public class ParcelTest {

    private Parcel parcel;
    private ShadowParcel shadowParcel;

    @Before
    public void setup() {
        parcel = Parcel.obtain();
        shadowParcel = Robolectric.shadowOf(parcel);
    }

    @Test
    public void testObtain() {
        assertThat(parcel, notNullValue());
        assertThat(shadowParcel.getIndex(), equalTo(0));
        assertThat(shadowParcel.getParcelData().size(), equalTo(0));
    }

    @Test
    public void testReadIntWhenEmpty() {
        assertThat(parcel.readInt(), equalTo(0));
    }

    @Test
    public void testReadLongWhenEmpty() {
        assertThat(parcel.readLong(), equalTo(0l));
    }

    @Test
    public void testReadStringWhenEmpty() {
        assertThat(parcel.readString(), nullValue());
    }

    @Test
    public void testReadWriteSingleString() {
        String val = "test";
        parcel.writeString(val);
        parcel.setDataPosition(0);
        assertThat(parcel.readString(), equalTo(val));
    }

	@Test
	public void testWriteNullString() {
		parcel.writeString( null );
		parcel.setDataPosition(0);
		assertThat( parcel.readString(), nullValue() );
		assertThat( shadowParcel.getIndex(), equalTo( 1 ) );
		assertThat( shadowParcel.getParcelData().size(), equalTo( 1 ) );
	}

    @Test
    public void testReadWriteMultipleStrings() {
        for (int i = 0; i < 10; ++i) {
            parcel.writeString(Integer.toString(i));
        }
        parcel.setDataPosition(0);
        for (int i = 0; i < 10; ++i) {
            assertThat(parcel.readString(), equalTo(Integer.toString(i)));
        }
        // now try to read past the number of items written and see what happens
        assertThat(parcel.readString(), nullValue());
    }

    @Test
    public void testReadWriteSingleInt() {
        int val = 5;
        parcel.writeInt(val);
        parcel.setDataPosition(0);
        assertThat(parcel.readInt(), equalTo(val));
    }

    @Test
    public void testReadWriteIntArray() throws Exception {
        final int[] ints = {1, 2};
        parcel.writeIntArray(ints);
        parcel.setDataPosition(0);
        final int[] ints2 = new int[ints.length];
        parcel.readIntArray(ints2);
        assertTrue(Arrays.equals(ints, ints2));
    }

    @Test
    public void testReadWriteLongArray() throws Exception {
        final long[] longs = {1, 2};
        parcel.writeLongArray(longs);
        parcel.setDataPosition(0);
        final long[] longs2 = new long[longs.length];
        parcel.readLongArray(longs2);
        assertTrue(Arrays.equals(longs, longs2));
    }

    @Test
    public void testReadWriteSingleFloat() {
        float val = 5.2f;
        parcel.writeFloat(val);
        parcel.setDataPosition(0);
        assertThat(parcel.readFloat(), equalTo(val));
    }

    @Test
    public void testReadWriteFloatArray() throws Exception {
        final float[] floats = {1.1f, 2.0f};
        parcel.writeFloatArray(floats);
        parcel.setDataPosition(0);
        final float[] floats2 = new float[floats.length];
        parcel.readFloatArray(floats2);
        assertTrue(Arrays.equals(floats, floats2));
    }

    @Test
    public void testReadWriteDoubleArray() throws Exception {
        final double[] doubles = {1.1f, 2.0f};
        parcel.writeDoubleArray(doubles);
        parcel.setDataPosition(0);
        final double[] doubles2 = new double[doubles.length];
        parcel.readDoubleArray(doubles2);
        assertTrue(Arrays.equals(doubles, doubles2));
    }

    @Test
    public void testReadWriteStringArray() throws Exception {
        final String[] strings = {"foo", "bar"};
        parcel.writeStringArray(strings);
        parcel.setDataPosition(0);
        final String[] strings2 = new String[strings.length];
        parcel.readStringArray(strings2);
        assertTrue(Arrays.equals(strings, strings2));
    }

    @Test
    public void testReadWriteMultipleInts() {
        for (int i = 0; i < 10; ++i) {
            parcel.writeInt(i);
        }
        parcel.setDataPosition(0);
        for (int i = 0; i < 10; ++i) {
            assertThat(parcel.readInt(), equalTo(i));
        }
        // now try to read past the number of items written and see what happens
        assertThat(parcel.readInt(), equalTo(0));
    }

    @Test
    public void testReadWriteSingleByte() {
        byte val = 1;
        parcel.writeByte(val);
        parcel.setDataPosition(0);
        assertThat(parcel.readByte(), equalTo(val));
    }

    @Test
    public void testReadWriteMultipleBytes() {
        for (byte i = Byte.MIN_VALUE; i < Byte.MAX_VALUE; ++i) {
            parcel.writeByte(i);
        }
        parcel.setDataPosition(0);
        for (byte i = Byte.MIN_VALUE; i < Byte.MAX_VALUE; ++i) {
            assertThat(parcel.readByte(), equalTo(i));
        }
        // now try to read past the number of items written and see what happens
        assertThat(parcel.readByte(), equalTo((byte) 0));
    }


    @Test
    public void testReadWriteStringInt() {
        for (int i = 0; i < 10; ++i) {
            parcel.writeString(Integer.toString(i));
            parcel.writeInt(i);
        }
        parcel.setDataPosition(0);
        for (int i = 0; i < 10; ++i) {
            assertThat(parcel.readString(), equalTo(Integer.toString(i)));
            assertThat(parcel.readInt(), equalTo(i));
        }
        // now try to read past the number of items written and see what happens
        assertThat(parcel.readString(), nullValue());
        assertThat(parcel.readInt(), equalTo(0));
    }

    @Test
    public void testReadWriteSingleLong() {
        long val = 5;
        parcel.writeLong(val);
        parcel.setDataPosition(0);
        assertThat(parcel.readLong(), equalTo(val));
    }

    @Test
    public void testReadWriteMultipleLongs() {
        for (long i = 0; i < 10; ++i) {
            parcel.writeLong(i);
        }
        parcel.setDataPosition(0);
        for (long i = 0; i < 10; ++i) {
            assertThat(parcel.readLong(), equalTo(i));
        }
        // now try to read past the number of items written and see what happens
        assertThat(parcel.readLong(), equalTo(0l));
    }

    @Test
    public void testReadWriteStringLong() {
        for (long i = 0; i < 10; ++i) {
            parcel.writeString(Long.toString(i));
            parcel.writeLong(i);
        }
        parcel.setDataPosition(0);
        for (long i = 0; i < 10; ++i) {
            assertThat(parcel.readString(), equalTo(Long.toString(i)));
            assertThat(parcel.readLong(), equalTo(i));
        }
        // now try to read past the number of items written and see what happens
        assertThat(parcel.readString(), nullValue());
        assertThat(parcel.readLong(), equalTo(0l));
    }

    @Test
    public void testReadWriteParcelable() {
        Intent i1 = new Intent("anAction");
        parcel.writeParcelable(i1, 0);

        parcel.setDataPosition(0);

        Intent i2 = parcel.readParcelable(Intent.class.getClassLoader());
        assertEquals(i1, i2);
    }

    @Test
    public void testReadWriteSimpleBundle() {
        Bundle b1 = new Bundle();
        b1.putString("hello", "world");
        parcel.writeBundle(b1);
        parcel.setDataPosition(0);
        Bundle b2 = parcel.readBundle();

        assertEquals(b1, b2);
        assertEquals("world", b2.getString("hello"));

        parcel.setDataPosition(0);
        parcel.writeBundle(b1);
        parcel.setDataPosition(0);
        b2 = parcel.readBundle(null /* ClassLoader */);
        assertEquals(b1, b2);
        assertEquals("world", b2.getString("hello"));
    }

    @Test
    public void testReadWriteNestedBundles() {
        Account account = new Account("accountName", "accountType");
        Bundle innerBundle = new Bundle();
        innerBundle.putString("hello", "world");
        innerBundle.putParcelable("account", account);
        Bundle b1 = new Bundle();
        b1.putBundle("bundle", innerBundle);
        b1.putInt("int", 23);
        parcel.writeBundle(b1);
        parcel.setDataPosition(0);
        Bundle b2 = parcel.readBundle();

        assertEquals(b1, b2);
        assertEquals(innerBundle, b2.getBundle("bundle"));
        assertEquals(23, b2.getInt("int"));
        assertEquals("world", b2.getBundle("bundle").getString("hello"));

        parcel.setDataPosition(0);
        parcel.writeBundle(b1);
        parcel.setDataPosition(0);
        b2 = parcel.readBundle(null /* ClassLoader */);
        assertEquals(b1, b2);
        assertEquals(innerBundle, b2.getBundle("bundle"));
        assertEquals(23, b2.getInt("int"));
        assertEquals("world", b2.getBundle("bundle").getString("hello"));
    }

    @Test
    public void testReadWriteBundleWithDifferentValueTypes() {
        Bundle b1 = new Bundle();
        b1.putString("hello", "world");
        b1.putBoolean("boolean", true);
        b1.putByte("byte", (byte) 0xAA);
        b1.putShort("short", (short)0xBABE);
        b1.putInt("int", 1);
        b1.putFloat("float", 0.5f);
        b1.putDouble("double", 1.25);
        parcel.writeBundle(b1);
        parcel.setDataPosition(0);

        Bundle b2 = parcel.readBundle();

        assertEquals(b1, b2);
        assertEquals("world", b2.getString("hello"));
        assertEquals(true, b2.getBoolean("boolean"));
        assertEquals((byte) 0xAA, b2.getByte("byte"));
        assertEquals((short) 0xBABE, b2.getShort("short"));
        assertEquals(1, b2.getInt("int"));
        assertEquals(0.5f, b2.getFloat("float"), 0.05);
        assertEquals(1.25, b2.getDouble("double"), 0.05);

        parcel.setDataPosition(0);
        parcel.writeBundle(b1);
        parcel.setDataPosition(0);
        b2 = parcel.readBundle(null /* ClassLoader */);
        assertEquals(b1, b2);
        assertEquals("world", b2.getString("hello"));
        assertEquals(true, b2.getBoolean("boolean"));
        assertEquals((byte) 0xAA, b2.getByte("byte"));
        assertEquals((short) 0xBABE, b2.getShort("short"));
        assertEquals(1, b2.getInt("int"));
        assertEquals(0.5f, b2.getFloat("float"), 0.05);
        assertEquals(1.25, b2.getDouble("double"), 0.05);
    }

    @Test
    public void testWriteCreateStringArray() {
      final String[] strings = { "foo", "bar" };
      parcel.writeStringArray(strings);
      parcel.setDataPosition(0);
      final String[] strings2 = parcel.createStringArray();
      assertTrue(Arrays.equals(strings, strings2));
    }

    @Test
    public void testReadWriteStringList() {
        final List<String> strings = Arrays.asList( "foo", "bar" );
        parcel.writeStringList(strings);
        parcel.setDataPosition(0);
        List<String> extractedStrings = new ArrayList<String>();
        parcel.readStringList(extractedStrings);
        assertEquals(strings, extractedStrings);
    }

    @Test
    public void testWriteCreateStringArrayList() {
        final List<String> strings = Arrays.asList( "foo", "bar" );
        parcel.writeStringList(strings);
        parcel.setDataPosition(0);
        List<String> extractedStrings = parcel.createStringArrayList();
        assertEquals(strings, extractedStrings);
    }

    @Test
    public void testReadWriteByteArray() throws Exception {
        final byte[] bytes = {1, 2};
        parcel.writeByteArray(bytes);
        parcel.setDataPosition(0);
        final byte[] bytes2 = new byte[bytes.length];
        parcel.readByteArray(bytes2);
        assertTrue(Arrays.equals(bytes, bytes2));
    }

    @Test
    public void testReadWriteBooleanArray() {
        final boolean[] booleans = {false, true, true};
        parcel.writeBooleanArray(booleans);
        parcel.setDataPosition(0);
        final boolean[] booleans2 = new boolean[booleans.length];
        parcel.readBooleanArray(booleans2);
        assertTrue(Arrays.equals(booleans, booleans2));
    }

    @Test
    public void testReadWriteCharArray() {
        final char[] chars = {'a', 'b', 'c'};
        parcel.writeCharArray(chars);
        parcel.setDataPosition(0);
        final char[] chars2 = new char[chars.length];
        parcel.readCharArray(chars2);
        assertTrue(Arrays.equals(chars, chars2));
    }

    @Test
    public void testWriteCreateBooleanArray() {
        final boolean[] booleans = {false, true, true};
        parcel.writeBooleanArray(booleans);
        parcel.setDataPosition(0);
        final boolean[] booleans2 = parcel.createBooleanArray();
        assertTrue(Arrays.equals(booleans, booleans2));
    }

    @Test
    public void testWriteCreateByteArray() {
        final byte[] bytes = {1, 2};
        parcel.writeByteArray(bytes);
        parcel.setDataPosition(0);
        final byte[] bytes2 = parcel.createByteArray();
        assertTrue(Arrays.equals(bytes, bytes2));
    }

    @Test
    public void testWriteCreateCharArray() {
        final char[] chars = {'a', 'b', 'c'};
        parcel.writeCharArray(chars);
        parcel.setDataPosition(0);
        final char[] chars2 = parcel.createCharArray();
        assertTrue(Arrays.equals(chars, chars2));
    }

    @Test
    public void testWriteCreateIntArray() {
        final int[] ints = {1, 2};
        parcel.writeIntArray(ints);
        parcel.setDataPosition(0);
        final int[] ints2 = parcel.createIntArray();
        assertTrue(Arrays.equals(ints, ints2));
    }

    @Test
    public void testWriteCreateLongArray() {
        final long[] longs = {1, 2};
        parcel.writeLongArray(longs);
        parcel.setDataPosition(0);
        final long[] longs2 = parcel.createLongArray();
        assertTrue(Arrays.equals(longs, longs2));
    }

    @Test
    public void testWriteCreateFloatArray() {
        final float[] floats = {1.5f, 2.25f};
        parcel.writeFloatArray(floats);
        parcel.setDataPosition(0);
        final float[] floats2 = parcel.createFloatArray();
        assertTrue(Arrays.equals(floats, floats2));
    }

    @Test
    public void testWriteCreateDoubleArray() {
        final double[] doubles = {1.2, 2.2};
        parcel.writeDoubleArray(doubles);
        parcel.setDataPosition(0);
        final double[] doubles2 = parcel.createDoubleArray();
        assertTrue(Arrays.equals(doubles, doubles2));
    }

    @Test
    public void testDataPositionAfterStringWrite() {
      parcel.writeString("string");
      assertEquals(10, parcel.dataPosition());
    }

    @Test
    public void testDataPositionAfterByteWrite() {
      parcel.writeByte((byte) 0);
      assertEquals(1, parcel.dataPosition());
    }

    @Test
    public void testDataPositionAfterIntWrite() {
      parcel.writeInt(1);
      assertEquals(4, parcel.dataPosition());
    }

    @Test
    public void testDataPositionAfterLongWrite() {
      parcel.writeLong(23);
      assertEquals(8, parcel.dataPosition());
    }

    @Test
    public void testDataPositionAfterFloatWrite() {
      parcel.writeFloat(0.5f);
      assertEquals(4, parcel.dataPosition());
    }

    @Test
    public void testDataPositionAfterDoubleWrite() {
      parcel.writeDouble(8.8);
      assertEquals(8, parcel.dataPosition());
    }

    @Test
    public void testResetDataPositionAfterWrite() {
      parcel.writeInt(4);
      parcel.setDataPosition(0);
      assertEquals(0, parcel.dataPosition());
    }

    @Test
    public void testOverwritePreviousValue() {
      parcel.writeInt(4);
      parcel.setDataPosition(0);
      parcel.writeInt(34);
      parcel.setDataPosition(0);
      assertEquals(34, parcel.readInt());
      assertEquals(4, parcel.dataSize());
    }
}