summaryrefslogtreecommitdiffstats
path: root/mobile/android/geckoview/src/test
diff options
context:
space:
mode:
Diffstat (limited to 'mobile/android/geckoview/src/test')
-rw-r--r--mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/GeckoBundleTest.java745
-rw-r--r--mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/IntentUtilsTest.java66
-rw-r--r--mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/NetworkUtilsTest.java215
3 files changed, 1026 insertions, 0 deletions
diff --git a/mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/GeckoBundleTest.java b/mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/GeckoBundleTest.java
new file mode 100644
index 0000000000..8ef19ca696
--- /dev/null
+++ b/mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/GeckoBundleTest.java
@@ -0,0 +1,745 @@
+/* Any copyright is dedicated to the Public Domain.
+http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.util;
+
+import static org.junit.Assert.*;
+
+import android.os.Parcel;
+import android.test.suitebuilder.annotation.SmallTest;
+import java.util.Arrays;
+import java.util.List;
+import org.json.JSONException;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+@SmallTest
+public class GeckoBundleTest {
+ private static final int INNER_BUNDLE_SIZE = 28;
+ private static final int OUTER_BUNDLE_SIZE = INNER_BUNDLE_SIZE + 6;
+
+ private static GeckoBundle createInnerBundle() {
+ final GeckoBundle bundle = new GeckoBundle();
+
+ bundle.putBoolean("boolean", true);
+ bundle.putBooleanArray("booleanArray", new boolean[] {false, true});
+
+ bundle.putInt("int", 1);
+ bundle.putIntArray("intArray", new int[] {2, 3});
+
+ bundle.putDouble("double", 0.5);
+ bundle.putDoubleArray("doubleArray", new double[] {1.5, 2.5});
+
+ bundle.putLong("long", 1L);
+ bundle.putLongArray("longArray", new long[] {2L, 3L});
+
+ bundle.putString("string", "foo");
+ bundle.putString("nullString", null);
+ bundle.putString("emptyString", "");
+ bundle.putStringArray("stringArray", new String[] {"bar", "baz"});
+ bundle.putStringArray("stringArrayOfNull", new String[2]);
+
+ bundle.putBooleanArray("emptyBooleanArray", new boolean[0]);
+ bundle.putIntArray("emptyIntArray", new int[0]);
+ bundle.putDoubleArray("emptyDoubleArray", new double[0]);
+ bundle.putLongArray("emptyLongArray", new long[0]);
+ bundle.putStringArray("emptyStringArray", new String[0]);
+
+ bundle.putBooleanArray("nullBooleanArray", (boolean[]) null);
+ bundle.putIntArray("nullIntArray", (int[]) null);
+ bundle.putDoubleArray("nullDoubleArray", (double[]) null);
+ bundle.putLongArray("nullLongArray", (long[]) null);
+ bundle.putStringArray("nullStringArray", (String[]) null);
+
+ bundle.putDoubleArray("mixedArray", new double[] {1.0, 1.5});
+
+ bundle.putInt("byte", 1);
+ bundle.putInt("short", 1);
+ bundle.putDouble("float", 0.5);
+ bundle.putString("char", "f");
+
+ return bundle;
+ }
+
+ private static GeckoBundle createBundle() {
+ final GeckoBundle outer = createInnerBundle();
+ final GeckoBundle inner = createInnerBundle();
+
+ outer.putBundle("object", inner);
+ outer.putBundle("nullObject", null);
+ outer.putBundleArray("objectArray", new GeckoBundle[] {null, inner});
+ outer.putBundleArray("objectArrayOfNull", new GeckoBundle[2]);
+ outer.putBundleArray("emptyObjectArray", new GeckoBundle[0]);
+ outer.putBundleArray("nullObjectArray", (GeckoBundle[]) null);
+
+ return outer;
+ }
+
+ private static void checkInnerBundle(final GeckoBundle bundle, final int expectedSize) {
+ assertEquals(expectedSize, bundle.size());
+
+ assertEquals(true, bundle.getBoolean("boolean"));
+ assertArrayEquals(new boolean[] {false, true}, bundle.getBooleanArray("booleanArray"));
+
+ assertEquals(1, bundle.getInt("int"));
+ assertArrayEquals(new int[] {2, 3}, bundle.getIntArray("intArray"));
+
+ assertEquals(0.5, bundle.getDouble("double"), 0.0);
+ assertArrayEquals(new double[] {1.5, 2.5}, bundle.getDoubleArray("doubleArray"), 0.0);
+
+ assertEquals(1L, bundle.getLong("long"));
+ assertArrayEquals(new long[] {2L, 3L}, bundle.getLongArray("longArray"));
+
+ assertEquals("foo", bundle.getString("string"));
+ assertEquals(null, bundle.getString("nullString"));
+ assertEquals("", bundle.getString("emptyString"));
+ assertArrayEquals(new String[] {"bar", "baz"}, bundle.getStringArray("stringArray"));
+ assertArrayEquals(new String[2], bundle.getStringArray("stringArrayOfNull"));
+
+ assertArrayEquals(new boolean[0], bundle.getBooleanArray("emptyBooleanArray"));
+ assertArrayEquals(new int[0], bundle.getIntArray("emptyIntArray"));
+ assertArrayEquals(new double[0], bundle.getDoubleArray("emptyDoubleArray"), 0.0);
+ assertArrayEquals(new long[0], bundle.getLongArray("emptyLongArray"));
+ assertArrayEquals(new String[0], bundle.getStringArray("emptyStringArray"));
+
+ assertArrayEquals(null, bundle.getBooleanArray("nullBooleanArray"));
+ assertArrayEquals(null, bundle.getIntArray("nullIntArray"));
+ assertArrayEquals(null, bundle.getDoubleArray("nullDoubleArray"), 0.0);
+ assertArrayEquals(null, bundle.getLongArray("nullLongArray"));
+ assertArrayEquals(null, bundle.getStringArray("nullStringArray"));
+
+ assertArrayEquals(new double[] {1.0, 1.5}, bundle.getDoubleArray("mixedArray"), 0.0);
+
+ assertEquals(1, bundle.getInt("byte"));
+ assertEquals(1, bundle.getInt("short"));
+ assertEquals(0.5, bundle.getDouble("float"), 0.0);
+ assertEquals("f", bundle.getString("char"));
+ }
+
+ private static void checkBundle(final GeckoBundle bundle) {
+ checkInnerBundle(bundle, OUTER_BUNDLE_SIZE);
+
+ checkInnerBundle(bundle.getBundle("object"), INNER_BUNDLE_SIZE);
+ assertEquals(null, bundle.getBundle("nullObject"));
+
+ final GeckoBundle[] array = bundle.getBundleArray("objectArray");
+ assertNotNull(array);
+ assertEquals(2, array.length);
+ assertEquals(null, array[0]);
+ checkInnerBundle(array[1], INNER_BUNDLE_SIZE);
+
+ assertArrayEquals(new GeckoBundle[2], bundle.getBundleArray("objectArrayOfNull"));
+ assertArrayEquals(new GeckoBundle[0], bundle.getBundleArray("emptyObjectArray"));
+ assertArrayEquals(null, bundle.getBundleArray("nullObjectArray"));
+ }
+
+ private GeckoBundle reference;
+
+ @Before
+ public void prepareReference() {
+ reference = createBundle();
+ }
+
+ @Test
+ public void canConstructWithCapacity() {
+ new GeckoBundle(0);
+ new GeckoBundle(1);
+ new GeckoBundle(42);
+
+ try {
+ new GeckoBundle(-1);
+ fail("Should throw with -1 capacity");
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ @Test
+ public void canConstructWithBundle() {
+ assertEquals(reference, new GeckoBundle(reference));
+
+ try {
+ new GeckoBundle(null);
+ fail("Should throw with null bundle");
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ @Test
+ public void referenceShouldBeCorrect() {
+ checkBundle(reference);
+ }
+
+ @Test
+ public void equalsShouldReturnCorrectResult() {
+ assertTrue(reference.equals(reference));
+ assertFalse(reference.equals(null));
+
+ assertTrue(reference.equals(new GeckoBundle(reference)));
+ assertFalse(reference.equals(new GeckoBundle()));
+ }
+
+ @Test
+ public void toStringShouldNotReturnEmptyString() {
+ assertNotNull(reference.toString());
+ assertNotEquals("", reference.toString());
+ }
+
+ @Test
+ public void hashCodeShouldNotReturnZero() {
+ assertNotEquals(0, reference.hashCode());
+ }
+
+ private static void testRemove(final GeckoBundle bundle, final String key) {
+ if (bundle.get(key) != null) {
+ assertTrue(String.format("%s should exist", key), bundle.containsKey(key));
+ } else {
+ assertFalse(String.format("%s should not exist", key), bundle.containsKey(key));
+ }
+ bundle.remove(key);
+ assertFalse(String.format("%s should not exist", key), bundle.containsKey(key));
+ }
+
+ @Test
+ public void containsKeyAndRemoveShouldWork() {
+ final GeckoBundle test = new GeckoBundle(reference);
+
+ testRemove(test, "nonexistent");
+ testRemove(test, "boolean");
+ testRemove(test, "booleanArray");
+ testRemove(test, "int");
+ testRemove(test, "intArray");
+ testRemove(test, "double");
+ testRemove(test, "doubleArray");
+ testRemove(test, "long");
+ testRemove(test, "longArray");
+ testRemove(test, "string");
+ testRemove(test, "nullString");
+ testRemove(test, "emptyString");
+ testRemove(test, "stringArray");
+ testRemove(test, "stringArrayOfNull");
+ testRemove(test, "emptyBooleanArray");
+ testRemove(test, "emptyIntArray");
+ testRemove(test, "emptyDoubleArray");
+ testRemove(test, "emptyLongArray");
+ testRemove(test, "emptyStringArray");
+ testRemove(test, "nullBooleanArray");
+ testRemove(test, "nullIntArray");
+ testRemove(test, "nullDoubleArray");
+ testRemove(test, "nullLongArray");
+ testRemove(test, "nullStringArray");
+ testRemove(test, "mixedArray");
+ testRemove(test, "byte");
+ testRemove(test, "short");
+ testRemove(test, "float");
+ testRemove(test, "char");
+ testRemove(test, "object");
+ testRemove(test, "nullObject");
+ testRemove(test, "objectArray");
+ testRemove(test, "objectArrayOfNull");
+ testRemove(test, "emptyObjectArray");
+ testRemove(test, "nullObjectArray");
+
+ assertEquals(0, test.size());
+ }
+
+ @Test
+ public void clearShouldWork() {
+ final GeckoBundle test = new GeckoBundle(reference);
+ assertNotEquals(0, test.size());
+ test.clear();
+ assertEquals(0, test.size());
+ }
+
+ @Test
+ public void keysShouldReturnCorrectResult() {
+ final String[] actual = reference.keys();
+ final String[] expected =
+ new String[] {
+ "boolean",
+ "booleanArray",
+ "int",
+ "intArray",
+ "double",
+ "doubleArray",
+ "long",
+ "longArray",
+ "string",
+ "nullString",
+ "emptyString",
+ "stringArray",
+ "stringArrayOfNull",
+ "emptyBooleanArray",
+ "emptyIntArray",
+ "emptyDoubleArray",
+ "emptyLongArray",
+ "emptyStringArray",
+ "nullBooleanArray",
+ "nullIntArray",
+ "nullDoubleArray",
+ "nullLongArray",
+ "nullStringArray",
+ "mixedArray",
+ "byte",
+ "short",
+ "float",
+ "char",
+ "object",
+ "nullObject",
+ "objectArray",
+ "objectArrayOfNull",
+ "emptyObjectArray",
+ "nullObjectArray"
+ };
+
+ Arrays.sort(expected);
+ Arrays.sort(actual);
+
+ assertArrayEquals(expected, actual);
+ }
+
+ @Test
+ public void isEmptyShouldReturnCorrectResult() {
+ assertFalse(reference.isEmpty());
+ assertTrue(new GeckoBundle().isEmpty());
+ }
+
+ @Test
+ public void getExistentKeysShouldNotReturnDefaultValues() {
+ assertNotEquals(false, reference.getBoolean("boolean", false));
+ assertNotEquals(0, reference.getInt("int", 0));
+ assertNotEquals(0.0, reference.getDouble("double", 0.0), 0.0);
+ assertNotEquals(0L, reference.getLong("long", 0L));
+ assertNotEquals("", reference.getString("string", ""));
+ }
+
+ private static void testDefaultValueForNull(final GeckoBundle bundle, final String key) {
+ // We return default values for null values.
+ assertEquals(true, bundle.getBoolean(key, true));
+ assertEquals(1, bundle.getInt(key, 1));
+ assertEquals(0.5, bundle.getDouble(key, 0.5), 0.0);
+ assertEquals("foo", bundle.getString(key, "foo"));
+ }
+
+ @Test
+ public void getNonexistentKeysShouldReturnDefaultValues() {
+ assertEquals(null, reference.get("nonexistent"));
+
+ assertEquals(false, reference.getBoolean("nonexistent"));
+ assertEquals(true, reference.getBoolean("nonexistent", true));
+ assertEquals(0, reference.getInt("nonexistent"));
+ assertEquals(1, reference.getInt("nonexistent", 1));
+ assertEquals(0.0, reference.getDouble("nonexistent"), 0.0);
+ assertEquals(0.5, reference.getDouble("nonexistent", 0.5), 0.0);
+ assertEquals(null, reference.getString("nonexistent"));
+ assertEquals("foo", reference.getString("nonexistent", "foo"));
+ assertEquals(null, reference.getBundle("nonexistent"));
+
+ assertArrayEquals(null, reference.getBooleanArray("nonexistent"));
+ assertArrayEquals(null, reference.getIntArray("nonexistent"));
+ assertArrayEquals(null, reference.getDoubleArray("nonexistent"), 0.0);
+ assertArrayEquals(null, reference.getLongArray("nonexistent"));
+ assertArrayEquals(null, reference.getStringArray("nonexistent"));
+ assertArrayEquals(null, reference.getBundleArray("nonexistent"));
+
+ // We return default values for null values.
+ testDefaultValueForNull(reference, "nullObject");
+ testDefaultValueForNull(reference, "nullString");
+ testDefaultValueForNull(reference, "nullBooleanArray");
+ testDefaultValueForNull(reference, "nullIntArray");
+ testDefaultValueForNull(reference, "nullDoubleArray");
+ testDefaultValueForNull(reference, "nullLongArray");
+ testDefaultValueForNull(reference, "nullStringArray");
+ testDefaultValueForNull(reference, "nullObjectArray");
+ }
+
+ @Test
+ public void bundleConversionShouldWork() {
+ assertEquals(reference, GeckoBundle.fromBundle(reference.toBundle()));
+ }
+
+ @Test
+ public void jsonConversionShouldWork() throws JSONException {
+ assertEquals(reference, GeckoBundle.fromJSONObject(reference.toJSONObject()));
+ }
+
+ @Test
+ public void parcelConversionShouldWork() {
+ final Parcel parcel = Parcel.obtain();
+
+ reference.writeToParcel(parcel, 0);
+ reference.writeToParcel(parcel, 0);
+ parcel.setDataPosition(0);
+
+ assertEquals(reference, GeckoBundle.CREATOR.createFromParcel(parcel));
+
+ final GeckoBundle test = new GeckoBundle();
+ test.readFromParcel(parcel);
+ assertEquals(reference, test);
+
+ parcel.recycle();
+ }
+
+ private static void testInvalidCoercions(
+ final GeckoBundle bundle, final String key, final String... exceptions) {
+ final List<String> allowed;
+ if (exceptions == null) {
+ allowed = Arrays.asList(key);
+ } else {
+ allowed = Arrays.asList(Arrays.copyOf(exceptions, exceptions.length + 1));
+ allowed.set(exceptions.length, key);
+ }
+
+ if (!allowed.contains("boolean")) {
+ try {
+ bundle.getBoolean(key);
+ fail(String.format("%s should not coerce to boolean", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("booleanArray")
+ && !allowed.contains("emptyBooleanArray")
+ && !allowed.contains("nullBooleanArray")) {
+ try {
+ bundle.getBooleanArray(key);
+ fail(String.format("%s should not coerce to boolean array", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("int")) {
+ try {
+ bundle.getInt(key);
+ fail(String.format("%s should not coerce to int", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("intArray")
+ && !allowed.contains("emptyIntArray")
+ && !allowed.contains("nullIntArray")) {
+ try {
+ bundle.getIntArray(key);
+ fail(String.format("%s should not coerce to int array", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("double")) {
+ try {
+ bundle.getDouble(key);
+ fail(String.format("%s should not coerce to double", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("doubleArray")
+ && !allowed.contains("emptyDoubleArray")
+ && !allowed.contains("nullDoubleArray")) {
+ try {
+ bundle.getDoubleArray(key);
+ fail(String.format("%s should not coerce to double array", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("long")) {
+ try {
+ bundle.getLong(key);
+ fail(String.format("%s should not coerce to long", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("longArray")
+ && !allowed.contains("emptyLongArray")
+ && !allowed.contains("nullLongArray")) {
+ try {
+ bundle.getLongArray(key);
+ fail(String.format("%s should not coerce to long array", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("string") && !allowed.contains("nullString")) {
+ try {
+ bundle.getString(key);
+ fail(String.format("%s should not coerce to string", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("stringArray")
+ && !allowed.contains("emptyStringArray")
+ && !allowed.contains("nullStringArray")
+ && !allowed.contains("stringArrayOfNull")) {
+ try {
+ bundle.getStringArray(key);
+ fail(String.format("%s should not coerce to string array", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("object") && !allowed.contains("nullObject")) {
+ try {
+ bundle.getBundle(key);
+ fail(String.format("%s should not coerce to bundle", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ if (!allowed.contains("objectArray")
+ && !allowed.contains("emptyObjectArray")
+ && !allowed.contains("nullObjectArray")
+ && !allowed.contains("objectArrayOfNull")) {
+ try {
+ bundle.getBundleArray(key);
+ fail(String.format("%s should not coerce to bundle array", key));
+ } catch (final Exception e) {
+ assertTrue(true);
+ }
+ }
+ }
+
+ @Test
+ public void booleanShouldNotCoerceToOtherTypes() {
+ testInvalidCoercions(reference, "boolean");
+ }
+
+ @Test
+ public void booleanArrayShouldNotCoerceToOtherTypes() {
+ testInvalidCoercions(reference, "booleanArray");
+ }
+
+ @Test
+ public void intShouldCoerceToDouble() {
+ assertEquals(1.0, reference.getDouble("int"), 0.0);
+ assertArrayEquals(new double[] {2.0, 3.0}, reference.getDoubleArray("intArray"), 0.0);
+ }
+
+ @Test
+ public void intShouldCoerceToLong() {
+ assertEquals(1L, reference.getLong("int"));
+ assertArrayEquals(new long[] {2L, 3L}, reference.getLongArray("intArray"));
+ }
+
+ @Test
+ public void intShouldNotCoerceToOtherTypes() {
+ testInvalidCoercions(reference, "int", /* except */ "double", "long");
+ testInvalidCoercions(reference, "intArray", /* except */ "doubleArray", "longArray");
+ }
+
+ @Test
+ public void doubleShouldCoerceToInt() {
+ assertEquals(0, reference.getInt("double"));
+ assertArrayEquals(new int[] {1, 2}, reference.getIntArray("doubleArray"));
+ }
+
+ @Test
+ public void doubleShouldCoerceToLong() {
+ assertEquals(0L, reference.getLong("double"));
+ assertArrayEquals(new long[] {1L, 2L}, reference.getLongArray("doubleArray"));
+ }
+
+ @Test
+ public void doubleShouldNotCoerceToOtherTypes() {
+ testInvalidCoercions(reference, "double", /* except */ "int", "long");
+ testInvalidCoercions(reference, "doubleArray", /* except */ "intArray", "longArray");
+ }
+
+ @Test
+ public void longShouldCoerceToInt() {
+ assertEquals(1, reference.getInt("long"));
+ assertArrayEquals(new int[] {2, 3}, reference.getIntArray("longArray"));
+ }
+
+ @Test
+ public void longShouldCoerceToDouble() {
+ assertEquals(1.0, reference.getDouble("long"), 0.0);
+ assertArrayEquals(new double[] {2.0, 3.0}, reference.getDoubleArray("longArray"), 0.0);
+ }
+
+ @Test
+ public void longShouldNotCoerceToOtherTypes() {
+ testInvalidCoercions(reference, "long", /* except */ "int", "double");
+ testInvalidCoercions(reference, "longArray", /* except */ "intArray", "doubleArray");
+ }
+
+ @Test
+ public void nullStringShouldCoerceToBundle() {
+ assertEquals(null, reference.getBundle("nullString"));
+ assertArrayEquals(new GeckoBundle[2], reference.getBundleArray("stringArrayOfNull"));
+ }
+
+ @Test
+ public void nullStringShouldNotCoerceToOtherTypes() {
+ testInvalidCoercions(reference, "stringArrayOfNull", /* except */ "objectArrayOfNull");
+ }
+
+ @Test
+ public void nonNullStringShouldNotCoerceToOtherTypes() {
+ testInvalidCoercions(reference, "string");
+ }
+
+ @Test
+ public void nullBundleShouldCoerceToString() {
+ assertEquals(null, reference.getString("nullObject"));
+ assertArrayEquals(new String[2], reference.getStringArray("objectArrayOfNull"));
+ }
+
+ @Test
+ public void nullBundleShouldNotCoerceToOtherTypes() {
+ testInvalidCoercions(reference, "objectArrayOfNull", /* except */ "stringArrayOfNull");
+ }
+
+ @Test
+ public void nonNullBundleShouldNotCoerceToOtherTypes() {
+ testInvalidCoercions(reference, "object");
+ }
+
+ @Test
+ public void emptyArrayShouldCoerceToAnyArray() {
+ assertArrayEquals(new int[0], reference.getIntArray("emptyBooleanArray"));
+ assertArrayEquals(new double[0], reference.getDoubleArray("emptyBooleanArray"), 0.0);
+ assertArrayEquals(new long[0], reference.getLongArray("emptyBooleanArray"));
+ assertArrayEquals(new String[0], reference.getStringArray("emptyBooleanArray"));
+ assertArrayEquals(new GeckoBundle[0], reference.getBundleArray("emptyBooleanArray"));
+
+ assertArrayEquals(new boolean[0], reference.getBooleanArray("emptyIntArray"));
+ assertArrayEquals(new double[0], reference.getDoubleArray("emptyIntArray"), 0.0);
+ assertArrayEquals(new long[0], reference.getLongArray("emptyIntArray"));
+ assertArrayEquals(new String[0], reference.getStringArray("emptyIntArray"));
+ assertArrayEquals(new GeckoBundle[0], reference.getBundleArray("emptyIntArray"));
+
+ assertArrayEquals(new boolean[0], reference.getBooleanArray("emptyDoubleArray"));
+ assertArrayEquals(new int[0], reference.getIntArray("emptyDoubleArray"));
+ assertArrayEquals(new long[0], reference.getLongArray("emptyDoubleArray"));
+ assertArrayEquals(new String[0], reference.getStringArray("emptyDoubleArray"));
+ assertArrayEquals(new GeckoBundle[0], reference.getBundleArray("emptyDoubleArray"));
+
+ assertArrayEquals(new boolean[0], reference.getBooleanArray("emptyLongArray"));
+ assertArrayEquals(new int[0], reference.getIntArray("emptyLongArray"));
+ assertArrayEquals(new double[0], reference.getDoubleArray("emptyLongArray"), 0.0);
+ assertArrayEquals(new String[0], reference.getStringArray("emptyLongArray"));
+ assertArrayEquals(new GeckoBundle[0], reference.getBundleArray("emptyLongArray"));
+
+ assertArrayEquals(new boolean[0], reference.getBooleanArray("emptyStringArray"));
+ assertArrayEquals(new int[0], reference.getIntArray("emptyStringArray"));
+ assertArrayEquals(new double[0], reference.getDoubleArray("emptyStringArray"), 0.0);
+ assertArrayEquals(new long[0], reference.getLongArray("emptyStringArray"));
+ assertArrayEquals(new GeckoBundle[0], reference.getBundleArray("emptyStringArray"));
+
+ assertArrayEquals(new boolean[0], reference.getBooleanArray("emptyObjectArray"));
+ assertArrayEquals(new int[0], reference.getIntArray("emptyObjectArray"));
+ assertArrayEquals(new double[0], reference.getDoubleArray("emptyObjectArray"), 0.0);
+ assertArrayEquals(new long[0], reference.getLongArray("emptyObjectArray"));
+ assertArrayEquals(new String[0], reference.getStringArray("emptyObjectArray"));
+ }
+
+ @Test
+ public void emptyArrayShouldNotCoerceToOtherTypes() {
+ testInvalidCoercions(
+ reference,
+ "emptyBooleanArray", /* except */
+ "intArray",
+ "doubleArray",
+ "longArray",
+ "stringArray",
+ "objectArray");
+ testInvalidCoercions(
+ reference,
+ "emptyIntArray", /* except */
+ "booleanArray",
+ "doubleArray",
+ "longArray",
+ "stringArray",
+ "objectArray");
+ testInvalidCoercions(
+ reference,
+ "emptyDoubleArray", /* except */
+ "booleanArray",
+ "intArray",
+ "longArray",
+ "stringArray",
+ "objectArray");
+ testInvalidCoercions(
+ reference,
+ "emptyLongArray", /* except */
+ "booleanArray",
+ "intArray",
+ "doubleArray",
+ "stringArray",
+ "objectArray");
+ testInvalidCoercions(
+ reference,
+ "emptyStringArray", /* except */
+ "booleanArray",
+ "intArray",
+ "doubleArray",
+ "longArray",
+ "objectArray");
+ testInvalidCoercions(
+ reference,
+ "emptyObjectArray", /* except */
+ "booleanArray",
+ "intArray",
+ "doubleArray",
+ "longArray",
+ "stringArray");
+ }
+
+ @Test
+ public void nullArrayShouldCoerceToAnyArray() {
+ assertArrayEquals(null, reference.getIntArray("nullBooleanArray"));
+ assertArrayEquals(null, reference.getDoubleArray("nullBooleanArray"), 0.0);
+ assertArrayEquals(null, reference.getLongArray("nullBooleanArray"));
+ assertArrayEquals(null, reference.getStringArray("nullBooleanArray"));
+ assertArrayEquals(null, reference.getBundleArray("nullBooleanArray"));
+
+ assertArrayEquals(null, reference.getBooleanArray("nullIntArray"));
+ assertArrayEquals(null, reference.getDoubleArray("nullIntArray"), 0.0);
+ assertArrayEquals(null, reference.getLongArray("nullIntArray"));
+ assertArrayEquals(null, reference.getStringArray("nullIntArray"));
+ assertArrayEquals(null, reference.getBundleArray("nullIntArray"));
+
+ assertArrayEquals(null, reference.getBooleanArray("nullDoubleArray"));
+ assertArrayEquals(null, reference.getIntArray("nullDoubleArray"));
+ assertArrayEquals(null, reference.getLongArray("nullDoubleArray"));
+ assertArrayEquals(null, reference.getStringArray("nullDoubleArray"));
+ assertArrayEquals(null, reference.getBundleArray("nullDoubleArray"));
+
+ assertArrayEquals(null, reference.getBooleanArray("nullLongArray"));
+ assertArrayEquals(null, reference.getIntArray("nullLongArray"));
+ assertArrayEquals(null, reference.getDoubleArray("nullLongArray"), 0.0);
+ assertArrayEquals(null, reference.getStringArray("nullLongArray"));
+ assertArrayEquals(null, reference.getBundleArray("nullLongArray"));
+
+ assertArrayEquals(null, reference.getBooleanArray("nullStringArray"));
+ assertArrayEquals(null, reference.getIntArray("nullStringArray"));
+ assertArrayEquals(null, reference.getDoubleArray("nullStringArray"), 0.0);
+ assertArrayEquals(null, reference.getLongArray("nullStringArray"));
+ assertArrayEquals(null, reference.getBundleArray("nullStringArray"));
+
+ assertArrayEquals(null, reference.getBooleanArray("nullObjectArray"));
+ assertArrayEquals(null, reference.getIntArray("nullObjectArray"));
+ assertArrayEquals(null, reference.getDoubleArray("nullObjectArray"), 0.0);
+ assertArrayEquals(null, reference.getLongArray("nullObjectArray"));
+ assertArrayEquals(null, reference.getStringArray("nullObjectArray"));
+ }
+}
diff --git a/mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/IntentUtilsTest.java b/mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/IntentUtilsTest.java
new file mode 100644
index 0000000000..24315ff585
--- /dev/null
+++ b/mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/IntentUtilsTest.java
@@ -0,0 +1,66 @@
+/* Any copyright is dedicated to the Public Domain.
+http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.util;
+
+import static org.junit.Assert.*;
+
+import android.net.Uri;
+import android.test.suitebuilder.annotation.SmallTest;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+@SmallTest
+public class IntentUtilsTest {
+
+ @Test
+ public void shouldNormalizeUri() {
+ final String uri = "HTTPS://mozilla.org";
+ final Uri normUri = IntentUtils.normalizeUri(uri);
+ assertEquals("https://mozilla.org", normUri.toString());
+ }
+
+ @Test
+ public void safeHttpUri() {
+ final String uri = "https://mozilla.org";
+ assertTrue(IntentUtils.isUriSafeForScheme(uri));
+ }
+
+ @Test
+ public void safeIntentUri() {
+ final String uri = "intent:https://mozilla.org#Intent;end;";
+ assertTrue(IntentUtils.isUriSafeForScheme(uri));
+ }
+
+ @Test
+ public void unsafeIntentUri() {
+ final String uri = "intent:file:///storage/emulated/0/Download#Intent;end";
+ assertFalse(IntentUtils.isUriSafeForScheme(uri));
+ }
+
+ @Test
+ public void safeTelUri() {
+ final String uri = "tel:12345678";
+ assertTrue(IntentUtils.isUriSafeForScheme(uri));
+ }
+
+ @Test
+ public void unsafeTelUri() {
+ final String uri = "tel:#12345678";
+ assertFalse(IntentUtils.isUriSafeForScheme(uri));
+ }
+
+ @Test
+ public void unsafeHtmlEncodedTelUri() {
+ assertFalse(IntentUtils.isUriSafeForScheme("tel:*%2306%23"));
+ assertFalse(IntentUtils.isUriSafeForScheme("tel:%2A%2306%23"));
+ }
+
+ @Test
+ public void intentDataWithoutScheme() {
+ final String uri = "intent:non_scheme_intent#Intent;end";
+ assertTrue(IntentUtils.isUriSafeForScheme(uri));
+ }
+}
diff --git a/mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/NetworkUtilsTest.java b/mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/NetworkUtilsTest.java
new file mode 100644
index 0000000000..f5033041e3
--- /dev/null
+++ b/mobile/android/geckoview/src/test/java/org/mozilla/gecko/util/NetworkUtilsTest.java
@@ -0,0 +1,215 @@
+/* Any copyright is dedicated to the Public Domain.
+http://creativecommons.org/publicdomain/zero/1.0/ */
+
+package org.mozilla.gecko.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.telephony.TelephonyManager;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mozilla.gecko.util.NetworkUtils.ConnectionSubType;
+import org.mozilla.gecko.util.NetworkUtils.ConnectionType;
+import org.mozilla.gecko.util.NetworkUtils.NetworkStatus;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.shadow.api.Shadow;
+import org.robolectric.shadows.ShadowConnectivityManager;
+import org.robolectric.shadows.ShadowNetworkInfo;
+
+@RunWith(RobolectricTestRunner.class)
+public class NetworkUtilsTest {
+ private ConnectivityManager connectivityManager;
+ private ShadowConnectivityManager shadowConnectivityManager;
+
+ @Before
+ public void setUp() {
+ connectivityManager =
+ (ConnectivityManager)
+ RuntimeEnvironment.application.getSystemService(Context.CONNECTIVITY_SERVICE);
+
+ // Not using Shadows.shadowOf(connectivityManager) because of Robolectric bug when using API23+
+ // See: https://github.com/robolectric/robolectric/issues/1862
+ shadowConnectivityManager = (ShadowConnectivityManager) Shadow.extract(connectivityManager);
+ }
+
+ @Test
+ public void testIsConnected() throws Exception {
+ assertFalse(NetworkUtils.isConnected((ConnectivityManager) null));
+
+ shadowConnectivityManager.setActiveNetworkInfo(null);
+ assertFalse(NetworkUtils.isConnected(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_WIFI, 0, true, true));
+ assertTrue(NetworkUtils.isConnected(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.DISCONNECTED, ConnectivityManager.TYPE_WIFI, 0, true, false));
+ assertFalse(NetworkUtils.isConnected(connectivityManager));
+ }
+
+ @Test
+ public void testGetConnectionSubType() throws Exception {
+ assertEquals(ConnectionSubType.UNKNOWN, NetworkUtils.getConnectionSubType(null));
+
+ shadowConnectivityManager.setActiveNetworkInfo(null);
+ assertEquals(ConnectionSubType.UNKNOWN, NetworkUtils.getConnectionSubType(connectivityManager));
+
+ // We don't seem to care about figuring out all connection types. So...
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_VPN, 0, true, true));
+ assertEquals(ConnectionSubType.UNKNOWN, NetworkUtils.getConnectionSubType(connectivityManager));
+
+ // But anything below we should recognize.
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_ETHERNET, 0, true, true));
+ assertEquals(
+ ConnectionSubType.ETHERNET, NetworkUtils.getConnectionSubType(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_WIFI, 0, true, true));
+ assertEquals(ConnectionSubType.WIFI, NetworkUtils.getConnectionSubType(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_WIMAX, 0, true, true));
+ assertEquals(ConnectionSubType.WIMAX, NetworkUtils.getConnectionSubType(connectivityManager));
+
+ // Unknown mobile
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED,
+ ConnectivityManager.TYPE_MOBILE,
+ TelephonyManager.NETWORK_TYPE_UNKNOWN,
+ true,
+ true));
+ assertEquals(ConnectionSubType.UNKNOWN, NetworkUtils.getConnectionSubType(connectivityManager));
+
+ // 2G mobile types
+ final int[] cell2gTypes =
+ new int[] {
+ TelephonyManager.NETWORK_TYPE_GPRS,
+ TelephonyManager.NETWORK_TYPE_EDGE,
+ TelephonyManager.NETWORK_TYPE_CDMA,
+ TelephonyManager.NETWORK_TYPE_1xRTT,
+ TelephonyManager.NETWORK_TYPE_IDEN
+ };
+ for (int i = 0; i < cell2gTypes.length; i++) {
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED,
+ ConnectivityManager.TYPE_MOBILE,
+ cell2gTypes[i],
+ true,
+ true));
+ assertEquals(
+ ConnectionSubType.CELL_2G, NetworkUtils.getConnectionSubType(connectivityManager));
+ }
+
+ // 3G mobile types
+ final int[] cell3gTypes =
+ new int[] {
+ TelephonyManager.NETWORK_TYPE_UMTS,
+ TelephonyManager.NETWORK_TYPE_EVDO_0,
+ TelephonyManager.NETWORK_TYPE_EVDO_A,
+ TelephonyManager.NETWORK_TYPE_HSDPA,
+ TelephonyManager.NETWORK_TYPE_HSUPA,
+ TelephonyManager.NETWORK_TYPE_HSPA,
+ TelephonyManager.NETWORK_TYPE_EVDO_B,
+ TelephonyManager.NETWORK_TYPE_EHRPD,
+ TelephonyManager.NETWORK_TYPE_HSPAP
+ };
+ for (int i = 0; i < cell3gTypes.length; i++) {
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED,
+ ConnectivityManager.TYPE_MOBILE,
+ cell3gTypes[i],
+ true,
+ true));
+ assertEquals(
+ ConnectionSubType.CELL_3G, NetworkUtils.getConnectionSubType(connectivityManager));
+ }
+
+ // 4G mobile type
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED,
+ ConnectivityManager.TYPE_MOBILE,
+ TelephonyManager.NETWORK_TYPE_LTE,
+ true,
+ true));
+ assertEquals(ConnectionSubType.CELL_4G, NetworkUtils.getConnectionSubType(connectivityManager));
+ }
+
+ @Test
+ public void testGetConnectionType() {
+ shadowConnectivityManager.setActiveNetworkInfo(null);
+ assertEquals(ConnectionType.NONE, NetworkUtils.getConnectionType(connectivityManager));
+ assertEquals(ConnectionType.NONE, NetworkUtils.getConnectionType(null));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_VPN, 0, true, true));
+ assertEquals(ConnectionType.OTHER, NetworkUtils.getConnectionType(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_WIFI, 0, true, true));
+ assertEquals(ConnectionType.WIFI, NetworkUtils.getConnectionType(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_MOBILE, 0, true, true));
+ assertEquals(ConnectionType.CELLULAR, NetworkUtils.getConnectionType(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_ETHERNET, 0, true, true));
+ assertEquals(ConnectionType.ETHERNET, NetworkUtils.getConnectionType(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED,
+ ConnectivityManager.TYPE_BLUETOOTH,
+ 0,
+ true,
+ true));
+ assertEquals(ConnectionType.BLUETOOTH, NetworkUtils.getConnectionType(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_WIMAX, 0, true, true));
+ assertEquals(ConnectionType.CELLULAR, NetworkUtils.getConnectionType(connectivityManager));
+ }
+
+ @Test
+ public void testGetNetworkStatus() {
+ assertEquals(NetworkStatus.UNKNOWN, NetworkUtils.getNetworkStatus(null));
+
+ shadowConnectivityManager.setActiveNetworkInfo(null);
+ assertEquals(NetworkStatus.DOWN, NetworkUtils.getNetworkStatus(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTING, ConnectivityManager.TYPE_MOBILE, 0, true, false));
+ assertEquals(NetworkStatus.DOWN, NetworkUtils.getNetworkStatus(connectivityManager));
+
+ shadowConnectivityManager.setActiveNetworkInfo(
+ ShadowNetworkInfo.newInstance(
+ NetworkInfo.DetailedState.CONNECTED, ConnectivityManager.TYPE_MOBILE, 0, true, true));
+ assertEquals(NetworkStatus.UP, NetworkUtils.getNetworkStatus(connectivityManager));
+ }
+}