1package com.xtremelabs.robolectric.shadows;
2
3import static com.xtremelabs.robolectric.Robolectric.shadowOf_;
4
5import java.io.Serializable;
6import java.util.ArrayList;
7import java.util.HashMap;
8import java.util.Map;
9import java.util.Set;
10
11import android.os.Build;
12import android.os.Bundle;
13import android.os.Parcelable;
14
15import com.xtremelabs.robolectric.Robolectric;
16import com.xtremelabs.robolectric.internal.Implementation;
17import com.xtremelabs.robolectric.internal.Implements;
18
19@SuppressWarnings({ "UnusedDeclaration" })
20@Implements(Bundle.class)
21public class ShadowBundle {
22    Map<String, Object> map = new HashMap<String, Object>();
23
24    public void __constructor__(Bundle b) {
25        putAll(b);
26    }
27
28    @Implementation
29    public void clear() {
30        map.clear();
31    }
32
33    @Implementation
34    public void remove(String key) {
35        map.remove(key);
36    }
37
38    @Implementation
39    public Object get(String key) {
40        return map.get(key);
41    }
42
43    @Implementation
44    public void putString(String key, String value) {
45        map.put(key, value);
46    }
47
48    @Implementation
49    public String getString(String key) {
50        Object value = map.get(key);
51        return value == null || !(value instanceof String) ? null : (String) value;
52    }
53
54    @Implementation
55    public String getString(String key, String defaultValue) {
56        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR1) {
57            throw new RuntimeException(new NoSuchMethodException("Requires API_12"));
58        }
59        Object value = map.get(key);
60        return value == null || !(value instanceof String) ? defaultValue : (String) value;
61    }
62
63    @Implementation
64    public void putLong(String key, long value) {
65        map.put(key, value);
66    }
67
68    @Implementation
69    public long getLong(String key) {
70        return getLong(key, 0);
71    }
72
73    @Implementation
74    public long getLong(String key, long defaultValue) {
75        Object value = map.get(key);
76        return value == null || !(value instanceof Long) ? defaultValue : (Long) value;
77    }
78
79    @Implementation
80    public void putInt(String key, int value) {
81        map.put(key, value);
82    }
83
84    @Implementation
85    public int getInt(String key) {
86        return getInt(key, 0);
87    }
88
89    @Implementation
90    public int getInt(String key, int defaultValue) {
91        Object value = map.get(key);
92        return value == null || !(value instanceof Integer) ? defaultValue : (Integer) value;
93    }
94
95    @Implementation
96    public void putDouble(String key, double value) {
97        map.put(key, value);
98    }
99
100    @Implementation
101    public double getDouble(String key) {
102        return getDouble(key, 0);
103    }
104
105    @Implementation
106    public double getDouble(String key, double defaultValue) {
107        Object value = map.get(key);
108        return value == null || !(value instanceof Double) ? defaultValue : (Double) value;
109    }
110
111    @Implementation
112    public void putBoolean(String key, boolean value) {
113        map.put(key, value);
114    }
115
116    @Implementation
117    public boolean getBoolean(String key) {
118        return getBoolean(key, false);
119    }
120
121    @Implementation
122    public boolean getBoolean(String key, boolean defaultValue) {
123        Object value = map.get(key);
124        return value == null || !(value instanceof Boolean) ? defaultValue : (Boolean) value;
125    }
126
127    @Implementation
128    public void putChar(String key, char value) {
129        map.put(key, value);
130    }
131
132    @Implementation
133    public char getChar(String key) {
134        return getChar(key, (char) 0);
135    }
136
137    @Implementation
138    public char getChar(String key, char defaultValue) {
139        Object value = map.get(key);
140        return value == null || !(value instanceof Character) ? defaultValue : (Character) value;
141    }
142
143    @Implementation
144    public void putCharSequence(String key, CharSequence value) {
145        map.put(key, value);
146    }
147
148    @Implementation
149    public CharSequence getCharSequence(String key) {
150        Object value = map.get(key);
151        return value == null || !(value instanceof CharSequence) ? null : (CharSequence) value;
152    }
153
154    @Implementation
155    public void putFloat(String key, float value) {
156        map.put(key, value);
157    }
158
159    @Implementation
160    public float getFloat(String key) {
161        return getFloat(key, 0);
162    }
163
164    @Implementation
165    public float getFloat(String key, float defaultValue) {
166        Object value = map.get(key);
167        return value == null || !(value instanceof Float) ? defaultValue : (Float) value;
168    }
169
170    @Implementation
171    public void putSerializable(String key, Serializable value) {
172        map.put(key, value);
173    }
174
175    @Implementation
176    public Serializable getSerializable(String key) {
177        Object value = map.get(key);
178        return value == null || !(value instanceof Serializable) ? null : (Serializable) value;
179    }
180
181    @Implementation
182    public void putParcelable(String key, Parcelable value) {
183        map.put(key, value);
184    }
185
186    @Implementation
187    public void putParcelableArrayList(String key, ArrayList<? extends Parcelable> value) {
188        map.put(key, value);
189    }
190
191    @Implementation
192    public Parcelable getParcelable(String key) {
193        Object value = map.get(key);
194        return value == null || !(value instanceof Parcelable) ? null : (Parcelable) value;
195    }
196
197    @Implementation
198    public ArrayList<Parcelable> getParcelableArrayList(String key) {
199        Object value = map.get(key);
200        return value == null || !(value instanceof ArrayList) ? null
201                : (ArrayList<Parcelable>) value;
202    }
203
204    @Implementation
205    public Parcelable[] getParcelableArray(String key) {
206        Object value = map.get(key);
207        return value == null || !(value instanceof Parcelable[]) ? null : (Parcelable[]) value;
208    }
209
210    @Implementation
211    public void putParcelableArray(String key, Parcelable[] value) {
212        map.put(key, value);
213    }
214
215    @Implementation
216    public void putStringArrayList(String key, ArrayList<String> value) {
217        map.put(key, value);
218    }
219
220    @Implementation
221    public ArrayList<String> getStringArrayList(String key) {
222        Object value = map.get(key);
223        return value == null || !(value instanceof ArrayList) ? null : (ArrayList<String>) value;
224    }
225
226    @Implementation
227    public void putCharSequenceArrayList(String key, ArrayList<CharSequence> value) {
228        map.put(key, value);
229    }
230
231    @Implementation
232    public ArrayList<CharSequence> getCharSequenceArrayList(String key) {
233        Object value = map.get(key);
234        return value == null || !(value instanceof ArrayList) ? null
235                : (ArrayList<CharSequence>) value;
236    }
237
238    @Implementation
239    public void putIntegerArrayList(String key, ArrayList<Integer> value) {
240        map.put(key, value);
241    }
242
243    @Implementation
244    public ArrayList<Integer> getIntegerArrayList(String key) {
245        Object value = map.get(key);
246        return value == null || !(value instanceof ArrayList) ? null : (ArrayList<Integer>) value;
247    }
248
249    @Implementation
250    public void putBundle(String key, Bundle value) {
251        map.put(key, value);
252    }
253
254    @Implementation
255    public Bundle getBundle(String key) {
256        Object value = map.get(key);
257        return value == null || !(value instanceof Bundle) ? null : (Bundle) value;
258    }
259
260    @Implementation
261    public void putBooleanArray(String key, boolean[] value) {
262        map.put(key, value);
263    }
264
265    @Implementation
266    public boolean[] getBooleanArray(String key) {
267        Object value = map.get(key);
268        return value == null || !(value instanceof boolean[]) ? null : (boolean[]) value;
269    }
270
271    @Implementation
272    public void putByteArray(String key, byte[] value) {
273        map.put(key, value);
274    }
275
276    @Implementation
277    public byte[] getByteArray(String key) {
278        Object value = map.get(key);
279        return value == null || !(value instanceof byte[]) ? null : (byte[]) value;
280    }
281
282    @Implementation
283    public void putCharArray(String key, char[] value) {
284        map.put(key, value);
285    }
286
287    @Implementation
288    public char[] getCharArray(String key) {
289        Object value = map.get(key);
290        return value == null || !(value instanceof char[]) ? null : (char[]) value;
291    }
292
293    @Implementation
294    public void putDoubleArray(String key, double[] value) {
295        map.put(key, value);
296    }
297
298    @Implementation
299    public double[] getDoubleArray(String key) {
300        Object value = map.get(key);
301        return value == null || !(value instanceof double[]) ? null : (double[]) value;
302    }
303
304    @Implementation
305    public void putFloatArray(String key, float[] value) {
306        map.put(key, value);
307    }
308
309    @Implementation
310    public float[] getFloatArray(String key) {
311        Object value = map.get(key);
312        return value == null || !(value instanceof float[]) ? null : (float[]) value;
313    }
314
315    @Implementation
316    public void putIntArray(String key, int[] value) {
317        map.put(key, value);
318    }
319
320    @Implementation
321    public int[] getIntArray(String key) {
322        Object value = map.get(key);
323        return value == null || !(value instanceof int[]) ? null : (int[]) value;
324    }
325
326    @Implementation
327    public void putLongArray(String key, long[] value) {
328        map.put(key, value);
329    }
330
331    @Implementation
332    public long[] getLongArray(String key) {
333        Object value = map.get(key);
334        return value == null || !(value instanceof long[]) ? null : (long[]) value;
335    }
336
337    @Implementation
338    public void putShortArray(String key, short[] value) {
339        map.put(key, value);
340    }
341
342    @Implementation
343    public short[] getShortArray(String key) {
344        Object value = map.get(key);
345        return value == null || !(value instanceof short[]) ? null : (short[]) value;
346    }
347
348    @Implementation
349    public void putAll(Bundle bundle) {
350        map.putAll(((ShadowBundle) Robolectric.shadowOf_(bundle)).map);
351    }
352
353    @Implementation
354    public void putStringArray(String key, String[] value) {
355        map.put(key, value);
356    }
357
358    @Implementation
359    public String[] getStringArray(String key) {
360        Object value = map.get(key);
361        return value == null || !(value instanceof String[]) ? null : (String[]) value;
362    }
363
364    @Implementation
365    public void putCharSequenceArray(String key, CharSequence[] value) {
366        map.put(key, value);
367    }
368
369    @Implementation
370    public CharSequence[] getCharSequenceArray(String key) {
371        Object value = map.get(key);
372        return value == null || !(value instanceof CharSequence[]) ? null : (CharSequence[]) value;
373    }
374
375    @Implementation
376    public boolean containsKey(String key) {
377        return map.containsKey(key);
378    }
379
380    @Implementation
381    public boolean isEmpty() {
382        return map.isEmpty();
383    }
384
385    @Implementation
386    public Set<String> keySet() {
387        return map.keySet();
388    }
389
390    @Implementation
391    public int size() {
392        return map.size();
393    }
394
395    @Override
396    @Implementation
397    public boolean equals(Object o) {
398        if (o == null)
399            return false;
400        o = shadowOf_(o);
401        if (o == null)
402            return false;
403        if (this == o)
404            return true;
405        if (getClass() != o.getClass())
406            return false;
407
408        ShadowBundle that = (ShadowBundle) o;
409
410        if (map != null ? !map.equals(that.map) : that.map != null)
411            return false;
412
413        return true;
414    }
415
416    @Override
417    @Implementation
418    public int hashCode() {
419        return map != null ? map.hashCode() : 0;
420    }
421}
422