Home | History | Annotate | Download | only in shadows 
      1 package org.robolectric.shadows;
      2 
      3 import static org.assertj.core.api.Assertions.assertThat;
      4 import static org.junit.Assert.assertEquals;
      5 import static org.junit.Assert.assertTrue;
      6 import static org.junit.Assert.fail;
      7 
      8 import android.accounts.Account;
      9 import android.os.Bundle;
     10 import android.os.Parcel;
     11 import java.util.ArrayList;
     12 import java.util.Arrays;
     13 import java.util.HashMap;
     14 import java.util.List;
     15 import org.junit.After;
     16 import org.junit.Before;
     17 import org.junit.Ignore;
     18 import org.junit.Test;
     19 import org.junit.runner.RunWith;
     20 import org.robolectric.RobolectricTestRunner;
     21 
     22 @RunWith(RobolectricTestRunner.class)
     23 public class ShadowParcelTest {
     24 
     25   private Parcel parcel;
     26 
     27   @Before
     28   public void setup() {
     29     parcel = Parcel.obtain();
     30   }
     31 
     32   @After
     33   public void tearDown() {
     34     parcel.recycle();
     35   }
     36 
     37   @Test
     38   public void testObtain() {
     39     assertThat(parcel).isNotNull();
     40   }
     41 
     42   @Test
     43   public void testReadIntWhenEmpty() {
     44     assertThat(parcel.readInt()).isEqualTo(0);
     45   }
     46 
     47   @Test
     48   public void testReadLongWhenEmpty() {
     49     assertThat(parcel.readLong()).isEqualTo(0L);
     50   }
     51 
     52   @Test
     53   public void testReadStringWhenEmpty() {
     54     assertThat(parcel.readString()).isNull();
     55   }
     56 
     57   @Test
     58   public void testReadStrongBinderWhenEmpty() {
     59     assertThat(parcel.readStrongBinder()).isNull();
     60   }
     61 
     62   @Test
     63   public void testReadWriteSingleString() {
     64     String val = "test";
     65     parcel.writeString(val);
     66     parcel.setDataPosition(0);
     67     assertThat(parcel.readString()).isEqualTo(val);
     68   }
     69 
     70   @Test
     71   public void testWriteNullString() {
     72     parcel.writeString(null);
     73     parcel.setDataPosition(0);
     74     assertThat(parcel.readString()).isNull();
     75   }
     76 
     77   @Test
     78   public void testWriteEmptyString() {
     79     parcel.writeString("");
     80     parcel.setDataPosition(0);
     81     assertThat(parcel.readString()).isEmpty();
     82   }
     83 
     84   @Test
     85   public void testReadWriteMultipleStrings() {
     86     for (int i = 0; i < 10; ++i) {
     87       parcel.writeString(Integer.toString(i));
     88     }
     89     parcel.setDataPosition(0);
     90     for (int i = 0; i < 10; ++i) {
     91       assertThat(parcel.readString()).isEqualTo(Integer.toString(i));
     92     }
     93     // now try to read past the number of items written and see what happens
     94     assertThat(parcel.readString()).isNull();
     95   }
     96 
     97   @Test
     98   public void testReadWriteSingleInt() {
     99     int val = 5;
    100     parcel.writeInt(val);
    101     parcel.setDataPosition(0);
    102     assertThat(parcel.readInt()).isEqualTo(val);
    103   }
    104 
    105   @Test
    106   public void testReadWriteIntArray() throws Exception {
    107     final int[] ints = { 1, 2 };
    108     parcel.writeIntArray(ints);
    109     parcel.setDataPosition(0);
    110     final int[] ints2 = new int[ints.length];
    111     parcel.readIntArray(ints2);
    112     assertTrue(Arrays.equals(ints, ints2));
    113   }
    114 
    115   @Test
    116   public void testWriteAndCreateNullIntArray() throws Exception {
    117     parcel.writeIntArray(null);
    118     parcel.setDataPosition(0);
    119     assertThat(parcel.createIntArray()).isNull();
    120   }
    121 
    122   @Test
    123   public void testReadWriteLongArray() throws Exception {
    124     final long[] longs = { 1, 2 };
    125     parcel.writeLongArray(longs);
    126     parcel.setDataPosition(0);
    127     final long[] longs2 = new long[longs.length];
    128     parcel.readLongArray(longs2);
    129     assertTrue(Arrays.equals(longs, longs2));
    130   }
    131 
    132   @Test
    133   public void testWriteAndCreateNullLongArray() throws Exception {
    134     parcel.writeLongArray(null);
    135     parcel.setDataPosition(0);
    136     assertThat(parcel.createLongArray()).isNull();
    137   }
    138 
    139   @Test
    140   public void testReadWriteSingleFloat() {
    141     float val = 5.2f;
    142     parcel.writeFloat(val);
    143     parcel.setDataPosition(0);
    144     assertThat(parcel.readFloat()).isEqualTo(val);
    145   }
    146 
    147   @Test
    148   public void testReadWriteFloatArray() throws Exception {
    149     final float[] floats = { 1.1f, 2.0f };
    150     parcel.writeFloatArray(floats);
    151     parcel.setDataPosition(0);
    152     final float[] floats2 = new float[floats.length];
    153     parcel.readFloatArray(floats2);
    154     assertTrue(Arrays.equals(floats, floats2));
    155   }
    156 
    157   @Test
    158   public void testWriteAndCreateNullFloatArray() throws Exception {
    159     parcel.writeFloatArray(null);
    160     parcel.setDataPosition(0);
    161     assertThat(parcel.createFloatArray()).isNull();
    162   }
    163 
    164   @Test
    165   public void testReadWriteDoubleArray() throws Exception {
    166     final double[] doubles = { 1.1f, 2.0f };
    167     parcel.writeDoubleArray(doubles);
    168     parcel.setDataPosition(0);
    169     final double[] doubles2 = new double[doubles.length];
    170     parcel.readDoubleArray(doubles2);
    171     assertTrue(Arrays.equals(doubles, doubles2));
    172   }
    173 
    174   @Test
    175   public void testWriteAndCreateNullDoubleArray() throws Exception {
    176     parcel.writeDoubleArray(null);
    177     parcel.setDataPosition(0);
    178     assertThat(parcel.createDoubleArray()).isNull();
    179   }
    180 
    181   @Test
    182   public void testReadWriteStringArray() throws Exception {
    183     final String[] strings = { "foo", "bar" };
    184     parcel.writeStringArray(strings);
    185     parcel.setDataPosition(0);
    186     final String[] strings2 = new String[strings.length];
    187     parcel.readStringArray(strings2);
    188     assertTrue(Arrays.equals(strings, strings2));
    189   }
    190 
    191   @Test
    192   public void testWriteAndCreateNullStringArray() throws Exception {
    193     parcel.writeStringArray(null);
    194     parcel.setDataPosition(0);
    195     assertThat(parcel.createStringArray()).isNull();
    196   }
    197 
    198   @Test
    199   public void testWriteAndCreateByteArray() {
    200     byte[] bytes = new byte[] { -1, 2, 3, 127 };
    201     parcel.writeByteArray(bytes);
    202     parcel.setDataPosition(0);
    203     byte[] actualBytes = parcel.createByteArray();
    204     assertTrue(Arrays.equals(bytes, actualBytes));
    205   }
    206 
    207   @Test
    208   public void testWriteAndCreateNullByteArray() throws Exception {
    209     parcel.writeByteArray(null);
    210     parcel.setDataPosition(0);
    211     assertThat(parcel.createByteArray()).isNull();
    212   }
    213 
    214   @Test
    215   public void testWriteAndCreateByteArray_lengthZero() {
    216     byte[] bytes = new byte[] {};
    217     parcel.writeByteArray(bytes);
    218     parcel.setDataPosition(0);
    219     byte[] actualBytes = parcel.createByteArray();
    220     assertTrue(Arrays.equals(bytes, actualBytes));
    221   }
    222 
    223   @Test
    224   public void testReadWriteMultipleInts() {
    225     for (int i = 0; i < 10; ++i) {
    226       parcel.writeInt(i);
    227     }
    228     parcel.setDataPosition(0);
    229     for (int i = 0; i < 10; ++i) {
    230       assertThat(parcel.readInt()).isEqualTo(i);
    231     }
    232     // now try to read past the number of items written and see what happens
    233     assertThat(parcel.readInt()).isEqualTo(0);
    234   }
    235 
    236   @Test
    237   public void testReadWriteSingleByte() {
    238     byte val = 1;
    239     parcel.writeByte(val);
    240     parcel.setDataPosition(0);
    241     assertThat(parcel.readByte()).isEqualTo(val);
    242   }
    243 
    244   @Test
    245   public void testReadWriteMultipleBytes() {
    246     for (byte i = Byte.MIN_VALUE; i < Byte.MAX_VALUE; ++i) {
    247       parcel.writeByte(i);
    248     }
    249     parcel.setDataPosition(0);
    250     for (byte i = Byte.MIN_VALUE; i < Byte.MAX_VALUE; ++i) {
    251       assertThat(parcel.readByte()).isEqualTo(i);
    252     }
    253     // now try to read past the number of items written and see what happens
    254     assertThat(parcel.readByte()).isEqualTo((byte) 0);
    255   }
    256 
    257   @Test
    258   public void testReadWriteStringInt() {
    259     for (int i = 0; i < 10; ++i) {
    260       parcel.writeString(Integer.toString(i));
    261       parcel.writeInt(i);
    262     }
    263     parcel.setDataPosition(0);
    264     for (int i = 0; i < 10; ++i) {
    265       assertThat(parcel.readString()).isEqualTo(Integer.toString(i));
    266       assertThat(parcel.readInt()).isEqualTo(i);
    267     }
    268     // now try to read past the number of items written and see what happens
    269     assertThat(parcel.readString()).isNull();
    270     assertThat(parcel.readInt()).isEqualTo(0);
    271   }
    272 
    273   @Test(expected = ClassCastException.class)
    274   public void testWriteStringReadInt() {
    275     String val = "test";
    276     parcel.writeString(val);
    277     parcel.setDataPosition(0);
    278     parcel.readInt();
    279   }
    280 
    281   @Test(expected = ClassCastException.class)
    282   public void testWriteIntReadString() {
    283     int val = 9;
    284     parcel.writeInt(val);
    285     parcel.setDataPosition(0);
    286     parcel.readString();
    287   }
    288 
    289   @Test
    290   public void testReadWriteSingleLong() {
    291     long val = 5;
    292     parcel.writeLong(val);
    293     parcel.setDataPosition(0);
    294     assertThat(parcel.readLong()).isEqualTo(val);
    295   }
    296 
    297   @Test
    298   public void testReadWriteMultipleLongs() {
    299     for (long i = 0; i < 10; ++i) {
    300       parcel.writeLong(i);
    301     }
    302     parcel.setDataPosition(0);
    303     for (long i = 0; i < 10; ++i) {
    304       assertThat(parcel.readLong()).isEqualTo(i);
    305     }
    306     // now try to read past the number of items written and see what happens
    307     assertThat(parcel.readLong()).isEqualTo(0L);
    308   }
    309 
    310   @Test
    311   public void testReadWriteStringLong() {
    312     for (long i = 0; i < 10; ++i) {
    313       parcel.writeString(Long.toString(i));
    314       parcel.writeLong(i);
    315     }
    316     parcel.setDataPosition(0);
    317     for (long i = 0; i < 10; ++i) {
    318       assertThat(parcel.readString()).isEqualTo(Long.toString(i));
    319       assertThat(parcel.readLong()).isEqualTo(i);
    320     }
    321     // now try to read past the number of items written and see what happens
    322     assertThat(parcel.readString()).isNull();
    323     assertThat(parcel.readLong()).isEqualTo(0L);
    324   }
    325 
    326   @Test(expected = ClassCastException.class)
    327   public void testWriteStringReadLong() {
    328     String val = "test";
    329     parcel.writeString(val);
    330     parcel.setDataPosition(0);
    331     parcel.readLong();
    332   }
    333 
    334   @Test(expected = ClassCastException.class)
    335   public void testWriteLongReadString() {
    336     long val = 9;
    337     parcel.writeLong(val);
    338     parcel.setDataPosition(0);
    339     parcel.readString();
    340   }
    341 
    342   @Test
    343   public void testReadWriteParcelable() {
    344     Account a1 = new Account("name", "type");
    345     parcel.writeParcelable(a1, 0);
    346     parcel.setDataPosition(0);
    347 
    348     Account a2 = parcel.readParcelable(Account.class.getClassLoader());
    349     assertEquals(a1, a2);
    350   }
    351 
    352   @Test
    353   public void testReadWriteBundle() {
    354     Bundle b1 = new Bundle();
    355     b1.putString("hello", "world");
    356     parcel.writeBundle(b1);
    357     parcel.setDataPosition(0);
    358     Bundle b2 = parcel.readBundle();
    359 
    360     assertEquals("world", b2.getString("hello"));
    361 
    362     parcel.setDataPosition(0);
    363     parcel.writeBundle(b1);
    364     parcel.setDataPosition(0);
    365     b2 = parcel.readBundle(null /* ClassLoader */);
    366     assertEquals("world", b2.getString("hello"));
    367   }
    368 
    369   @Test
    370   public void testCreateStringArrayList() throws Exception {
    371     parcel.writeStringList(Arrays.asList("str1", "str2"));
    372     parcel.setDataPosition(0);
    373 
    374     List<String> actual = parcel.createStringArrayList();
    375     assertEquals(2, actual.size());
    376     assertEquals("str1", actual.get(0));
    377     assertEquals("str2", actual.get(1));
    378   }
    379 
    380   @Test
    381   public void testWriteTypedListAndCreateTypedArrayList() throws Exception {
    382     TestParcelable normal = new TestParcelable(23);
    383     ArrayList<TestParcelable> normals = new ArrayList<>();
    384     normals.add(normal);
    385 
    386     parcel.writeTypedList(normals);
    387     parcel.setDataPosition(0);
    388     List<org.robolectric.shadows.TestParcelable> rehydrated = parcel
    389         .createTypedArrayList(TestParcelable.CREATOR);
    390 
    391     assertEquals(1, rehydrated.size());
    392     assertEquals(23, rehydrated.get(0).contents);
    393   }
    394 
    395   @Test
    396   public void testReadAndWriteStringList() throws Exception {
    397     ArrayList<String> original = new ArrayList<>();
    398     List<String> rehydrated = new ArrayList<>();
    399     original.add("str1");
    400     original.add("str2");
    401     parcel.writeStringList(original);
    402     parcel.setDataPosition(0);
    403     parcel.readStringList(rehydrated);
    404     assertEquals(2, rehydrated.size());
    405     assertEquals("str1", rehydrated.get(0));
    406     assertEquals("str2", rehydrated.get(1));
    407   }
    408 
    409   @Test
    410   public void testReadWriteMap() throws Exception {
    411     HashMap<String, String> original = new HashMap<>();
    412     original.put("key", "value");
    413     parcel.writeMap(original);
    414     parcel.setDataPosition(0);
    415     HashMap<String, String> rehydrated = parcel.readHashMap(null);
    416 
    417     assertEquals("value", rehydrated.get("key"));
    418   }
    419 
    420   @Test
    421   public void testCreateStringArray() {
    422     String[] strs = { "a1", "b2" };
    423     parcel.writeStringArray(strs);
    424     parcel.setDataPosition(0);
    425     String[] newStrs = parcel.createStringArray();
    426     assertTrue(Arrays.equals(strs, newStrs));
    427   }
    428 
    429   @Test
    430   public void testDataPositionAfterSomeWrites() {
    431     parcel.writeInt(1);
    432     assertThat(parcel.dataPosition()).isEqualTo(4);
    433 
    434     parcel.writeFloat(5);
    435     assertThat(parcel.dataPosition()).isEqualTo(8);
    436 
    437     parcel.writeDouble(37);
    438     assertThat(parcel.dataPosition()).isEqualTo(16);
    439   }
    440 
    441   @Test
    442   public void testDataPositionAfterSomeReads() {
    443     parcel.writeInt(1);
    444     parcel.writeFloat(5);
    445     parcel.writeDouble(37);
    446     parcel.setDataPosition(0);
    447 
    448     parcel.readInt();
    449     assertThat(parcel.dataPosition()).isEqualTo(4);
    450 
    451     parcel.readFloat();
    452     assertThat(parcel.dataPosition()).isEqualTo(8);
    453 
    454     parcel.readDouble();
    455     assertThat(parcel.dataPosition()).isEqualTo(16);
    456   }
    457 
    458   @Test
    459   public void testDataSizeAfterSomeWrites() {
    460     parcel.writeInt(1);
    461     assertThat(parcel.dataSize()).isEqualTo(4);
    462 
    463     parcel.writeFloat(5);
    464     assertThat(parcel.dataSize()).isEqualTo(8);
    465 
    466     parcel.writeDouble(37);
    467     assertThat(parcel.dataSize()).isEqualTo(16);
    468   }
    469 
    470   @Test
    471   public void testDataAvail() {
    472     parcel.writeInt(1);
    473     parcel.writeFloat(5);
    474     parcel.writeDouble(6);
    475     parcel.setDataPosition(4);
    476 
    477     assertThat(parcel.dataAvail()).isEqualTo(12);
    478   }
    479 
    480   @Test
    481   public void testSetDataPositionIntoMiddleOfParcel() {
    482     parcel.writeInt(1);
    483     parcel.writeFloat(5);
    484     parcel.writeDouble(6);
    485     parcel.setDataPosition(4);
    486 
    487     assertThat(parcel.readFloat()).isEqualTo(5);
    488   }
    489 
    490   @Test
    491   public void testSetDataPositionToEmptyString() {
    492     parcel.writeString("");
    493     parcel.setDataPosition(parcel.dataPosition());
    494     parcel.writeString("something else");
    495 
    496     parcel.setDataPosition(0);
    497     assertThat(parcel.readString()).isEmpty();
    498   }
    499 
    500   @Test
    501   public void testAppendFrom() {
    502     parcel.writeInt(1);
    503     parcel.writeInt(2);
    504     parcel.writeInt(3);
    505     parcel.writeInt(4);
    506 
    507     Parcel parcel2 = Parcel.obtain();
    508     parcel2.appendFrom(parcel, 4, 8);
    509     parcel2.setDataPosition(0);
    510 
    511     assertThat(parcel2.readInt()).isEqualTo(2);
    512     assertThat(parcel2.readInt()).isEqualTo(3);
    513     assertThat(parcel2.dataSize()).isEqualTo(8);
    514   }
    515 
    516   @Test
    517   public void testMarshallAndUnmarshall() {
    518     parcel.writeInt(1);
    519     parcel.writeString("hello");
    520     parcel.writeDouble(25);
    521     parcel.writeFloat(1.25f);
    522     parcel.writeByte((byte) 0xAF);
    523 
    524     byte[] rawBytes = parcel.marshall();
    525     Parcel parcel2 = Parcel.obtain();
    526     parcel2.unmarshall(rawBytes, 0, rawBytes.length);
    527 
    528     assertThat(parcel2.readInt()).isEqualTo(1);
    529     assertThat(parcel2.readString()).isEqualTo("hello");
    530     assertThat(parcel2.readDouble()).isEqualTo(25.0);
    531     assertThat(parcel2.readFloat()).isEqualTo(1.25f);
    532     assertThat(parcel2.readByte()).isEqualTo((byte) 0xAF);
    533   }
    534 
    535   @Test @Ignore("Needs implementation in ShadowParcel.ByteBuffer")
    536   public void testSetDataSize() {
    537     parcel.setDataSize(8);
    538     assertThat(parcel.dataSize()).isEqualTo(8);
    539   }
    540 
    541   @Test @Ignore("Needs implementation in ShadowParcel.ByteBuffer")
    542   public void testSetDataCapacity() {
    543     parcel.setDataCapacity(8);
    544     assertThat(parcel.dataCapacity()).isEqualTo(8);
    545   }
    546 
    547   @Test
    548   public void testWriteAndEnforceCompatibleInterface() {
    549     parcel.writeInterfaceToken("com.example.IMyInterface");
    550     parcel.setDataPosition(0);
    551     parcel.enforceInterface("com.example.IMyInterface");
    552     // Nothing explodes
    553   }
    554 
    555   @Test
    556   public void testWriteAndEnforceIncompatibleInterface() {
    557     parcel.writeInterfaceToken("com.example.Derp");
    558     parcel.setDataPosition(0);
    559     try {
    560       parcel.enforceInterface("com.example.IMyInterface");
    561       fail("Expected SecurityException");
    562     } catch (SecurityException e) {
    563       // Expected
    564     }
    565   }
    566 }
    567