Removing telemetry and mapbox mobile events

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/AccountsManagerTest.java

@@ -7,7 +7,6 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
 
-import static com.mapbox.mapboxsdk.constants.MapboxConstants.KEY_PREFERENCE_SKU_TOKEN;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -32,31 +31,4 @@ public class AccountsManagerTest {
     assertFalse(AccountsManager.isExpired(now, futureValue));
     assertFalse(AccountsManager.isExpired(now, immediatePast));
   }
-
-  @Test
-  public void checksSkuTokenExternalManagement() {
-    SharedPreferences mockedSharedPreferences = mock(SharedPreferences.class);
-    when(mockedSharedPreferences.getString(KEY_PREFERENCE_SKU_TOKEN, "")).thenReturn("external-sku-token");
-    boolean isNotManaged = false;
-    AccountsManager theAccountsManager = new AccountsManager(mockedSharedPreferences, isNotManaged);
-
-    String skuToken = theAccountsManager.getSkuToken();
-
-    assertEquals("external-sku-token", skuToken);
-  }
-
-  @Test
-  public void checksSkuTokenInternalManagement() {
-    SharedPreferences mockedSharedPreferences = mock(SharedPreferences.class, RETURNS_DEEP_STUBS);
-    when(mockedSharedPreferences.getString("com.mapbox.mapboxsdk.accounts.userid", ""))
-      .thenReturn("any-user-id");
-    boolean isManaged = true;
-    AccountsManager theAccountsManager = new AccountsManager(mockedSharedPreferences, isManaged);
-
-    String skuToken = theAccountsManager.getSkuToken();
-
-    assertFalse(skuToken.isEmpty());
-    assertTrue(skuToken.startsWith("100"));
-    assertTrue(skuToken.endsWith("any-user-id"));
-  }
 }

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/MapboxInjector.java

@@ -18,7 +18,7 @@ public class MapboxInjector {
     inject(context, accessToken, null);
   }
 
-  public static void inject(@NonNull Context context, @NonNull String accessToken, @Nullable String skuToken) {
+  public static void inject(@NonNull Context context, @NonNull String accessToken) {
     Mapbox mapbox = new Mapbox(context, accessToken);
     try {
       Field instance = Mapbox.class.getDeclaredField(FIELD_INSTANCE);
@@ -29,7 +29,6 @@ public class MapboxInjector {
       accounts.setAccessible(true);
 
       AccountsManager manager = mock(AccountsManager.class);
-      when(manager.getSkuToken()).thenReturn(skuToken);
       accounts.set(mapbox, manager);
     } catch (Exception exception) {
       throw new AssertionError();

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/LocationComponentTest.kt

@@ -5,8 +5,8 @@ import android.content.res.Resources
 import android.content.res.TypedArray
 import android.location.Location
 import android.os.Looper
-import com.mapbox.android.core.location.LocationEngine
-import com.mapbox.android.core.location.LocationEngineRequest
+import com.mapbox.mapboxsdk.location.engine.LocationEngine
+import com.mapbox.mapboxsdk.location.engine.LocationEngineRequest
 import com.mapbox.mapboxsdk.R
 import com.mapbox.mapboxsdk.camera.CameraPosition
 import com.mapbox.mapboxsdk.location.LocationComponentConstants.TRANSITION_ANIMATION_DURATION_MS

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/engine/AndroidLocationEngineImplTest.java

@@ -0,0 +1,187 @@
+package com.mapbox.mapboxsdk.location.engine;
+
+import android.app.PendingIntent;
+import android.content.Context;
+import android.location.Criteria;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.os.Looper;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static junit.framework.TestCase.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.any;
+
+@RunWith(MockitoJUnitRunner.class)
+public class AndroidLocationEngineImplTest {
+  private static final double LATITUDE = 37.7749;
+  private static final double LONGITUDE = 122.4194;
+
+  @Mock
+  private LocationManager locationManagerMock;
+
+  private LocationEngine engine;
+  private AndroidLocationEngineImpl androidLocationEngineImpl;
+
+  @Before
+  public void setUp() {
+    Context context = mock(Context.class);
+    when(context.getSystemService(Context.LOCATION_SERVICE)).thenReturn(locationManagerMock);
+    androidLocationEngineImpl = new AndroidLocationEngineImpl(context);
+    engine = new LocationEngineProxy<>(androidLocationEngineImpl);
+  }
+
+  @Test
+  public void getLastLocation() throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(1);
+    final AtomicReference<LocationEngineResult> resultRef = new AtomicReference<>();
+
+    LocationEngineCallback<LocationEngineResult> callback = getCallback(resultRef, latch);
+    final Location location = getMockLocation(LATITUDE, LONGITUDE);
+    final LocationEngineResult expectedResult = getMockEngineResult(location);
+
+    when(locationManagerMock.getLastKnownLocation(anyString())).thenReturn(location);
+
+    engine.getLastLocation(callback);
+    assertTrue(latch.await(5, SECONDS));
+
+    LocationEngineResult result = resultRef.get();
+    assertThat(result.getLastLocation()).isEqualTo(expectedResult.getLastLocation());
+  }
+
+  @Test
+  public void createListener() {
+    LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class);
+    LocationListener locationListener = androidLocationEngineImpl.createListener(callback);
+    Location mockLocation = getMockLocation(LATITUDE, LONGITUDE);
+    locationListener.onLocationChanged(mockLocation);
+    ArgumentCaptor<LocationEngineResult> argument = ArgumentCaptor.forClass(LocationEngineResult.class);
+    verify(callback).onSuccess(argument.capture());
+
+    LocationEngineResult result = argument.getValue();
+    assertThat(result.getLastLocation()).isSameAs(mockLocation);
+  }
+
+  @Test
+  public void requestLocationUpdatesWithNoPower() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(10)
+      .setPriority(LocationEngineRequest.PRIORITY_NO_POWER).build();
+    LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class);
+    Looper looper = mock(Looper.class);
+    Criteria criteria = mock(Criteria.class);
+
+    engine.requestLocationUpdates(request, callback, looper);
+    verify(locationManagerMock, never()).getBestProvider(criteria, true);
+  }
+
+  @Test
+  public void requestLocationUpdatesBestProviderNull() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(10)
+      .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY).build();
+    LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class);
+    Looper looper = mock(Looper.class);
+    when(locationManagerMock.getBestProvider(any(Criteria.class), anyBoolean())).thenReturn(null);
+
+    engine.requestLocationUpdates(request, callback, looper);
+    assertThat(androidLocationEngineImpl.currentProvider).isEqualTo("passive");
+  }
+
+  @Test
+  public void requestLocationUpdatesWithPendingIntent() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(10)
+      .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY).build();
+    PendingIntent pendingIntent = mock(PendingIntent.class);
+
+    when(locationManagerMock.getBestProvider(any(Criteria.class), anyBoolean())).thenReturn(null);
+
+    engine.requestLocationUpdates(request, pendingIntent);
+    assertThat(androidLocationEngineImpl.currentProvider).isEqualTo("passive");
+  }
+
+  @Test
+  public void removeLocationUpdatesForInvalidListener() {
+    LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class);
+    engine.removeLocationUpdates(callback);
+    verify(locationManagerMock, never()).removeUpdates(any(LocationListener.class));
+  }
+
+  @Test
+  public void removeLocationUpdatesForPendingIntent() {
+    PendingIntent pendingIntent = mock(PendingIntent.class);
+    engine.removeLocationUpdates(pendingIntent);
+    verify(locationManagerMock, times(1)).removeUpdates(any(PendingIntent.class));
+  }
+
+  @Test
+  public void removeLocationUpdatesForValidListener() {
+    LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class);
+    LocationEngineRequest request = new LocationEngineRequest.Builder(10)
+      .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY).build();
+    engine.requestLocationUpdates(request, callback, mock(Looper.class));
+    engine.removeLocationUpdates(callback);
+    verify(locationManagerMock, times(1)).removeUpdates(any(LocationListener.class));
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void getLastLocationNullCallback() {
+    engine.getLastLocation(null);
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void requestLocationUpdatesNullCallback() {
+    engine.requestLocationUpdates(null, null, null);
+  }
+
+  @After
+  public void tearDown() {
+    reset(locationManagerMock);
+    engine = null;
+  }
+
+  private static LocationEngineCallback<LocationEngineResult> getCallback(
+    final AtomicReference<LocationEngineResult> resultRef,
+    final CountDownLatch latch) {
+    return new LocationEngineCallback<LocationEngineResult>() {
+      @Override
+      public void onSuccess(LocationEngineResult result) {
+        resultRef.set(result);
+        latch.countDown();
+      }
+
+      @Override
+      public void onFailure(Exception exception) {
+        exception.printStackTrace();
+      }
+    };
+  }
+
+  private static LocationEngineResult getMockEngineResult(Location location) {
+    return LocationEngineResult.create(location);
+  }
+
+  private static Location getMockLocation(double lat, double lon) {
+    Location location = mock(Location.class);
+    location.setLatitude(lat);
+    location.setLongitude(lon);
+    return location;
+  }
+}

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/engine/GoogleLocationEngineImplAdditionalTest.java

@@ -0,0 +1,128 @@
+package com.mapbox.mapboxsdk.location.engine;
+
+import android.location.Location;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+
+import com.google.android.gms.location.FusedLocationProviderClient;
+import com.google.android.gms.location.LocationCallback;
+import com.google.android.gms.location.LocationRequest;
+import com.google.android.gms.location.LocationResult;
+import com.google.android.gms.tasks.OnSuccessListener;
+import com.google.android.gms.tasks.Task;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.stubbing.Answer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class GoogleLocationEngineImplAdditionalTest {
+  private static final long INTERVAL = 1000L;
+  private LocationEngineProxy engine;
+  private Location location;
+  private List<Location> locationList = new ArrayList<>();
+  private FusedLocationProviderClient fusedLocationProviderClient;
+  private Task<Void> mockTask;
+  private Task<Location> mockLocationTask;
+
+  @Before
+  public void setUp() {
+    location = mock(Location.class);
+    when(location.getLatitude()).thenReturn(1.0);
+    when(location.getLongitude()).thenReturn(2.0);
+    locationList.clear();
+    locationList.add(location);
+    fusedLocationProviderClient = mock(FusedLocationProviderClient.class);
+    mockTask = mock(Task.class);
+    mockLocationTask = mock(Task.class);
+    when(fusedLocationProviderClient.getLastLocation()).thenReturn(mockLocationTask);
+    when(fusedLocationProviderClient
+      .requestLocationUpdates(any(LocationRequest.class), any(LocationCallback.class), any(Looper.class)))
+      .thenAnswer(new Answer<Task<Void>>() {
+        @Override
+        public Task<Void> answer(InvocationOnMock invocation) {
+          LocationCallback listener = (LocationCallback) invocation.getArguments()[1];
+          listener.onLocationResult(LocationResult.create(locationList));
+          return mockTask;
+        }
+      });
+
+    engine = new LocationEngineProxy<>(new GoogleLocationEngineImpl(fusedLocationProviderClient));
+  }
+
+  @Test
+  public void checkGetLastLocation() throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(1);
+
+    when(mockLocationTask.addOnSuccessListener(any(OnSuccessListener.class)))
+      .thenAnswer(new Answer<Object>() {
+        @Override
+        public Object answer(InvocationOnMock invocation) throws Throwable {
+          OnSuccessListener listener = (OnSuccessListener) invocation.getArguments()[0];
+          listener.onSuccess(location);
+          return mock(Task.class);
+        }
+      });
+    engine.getLastLocation(new LocationEngineCallback<LocationEngineResult>() {
+      @Override
+      public void onSuccess(LocationEngineResult result) {
+        List<Location> list = result.getLocations();
+        assertEquals(1, list.size());
+        assertEquals(1.0, list.get(0).getLatitude(), 0);
+        assertEquals(2.0, list.get(0).getLongitude(), 0);
+        latch.countDown();
+      }
+
+      @Override
+      public void onFailure(@NonNull Exception exception) {
+
+      }
+    });
+    assertTrue(latch.await(1, TimeUnit.SECONDS));
+  }
+
+  @Test
+  public void checkRequestAndRemoveLocationUpdates() throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(1);
+
+    LocationEngineCallback<LocationEngineResult> engineCallback = new LocationEngineCallback<LocationEngineResult>() {
+      @Override
+      public void onSuccess(LocationEngineResult result) {
+        List<Location> list = result.getLocations();
+        assertEquals(1, list.size());
+        assertEquals(1.0, list.get(0).getLatitude(), 0);
+        assertEquals(2.0, list.get(0).getLongitude(), 0);
+        latch.countDown();
+      }
+
+      @Override
+      public void onFailure(@NonNull Exception exception) {
+
+      }
+    };
+    engine.requestLocationUpdates(getRequest(INTERVAL, LocationEngineRequest.PRIORITY_HIGH_ACCURACY),
+      engineCallback, mock(Looper.class));
+    assertTrue(latch.await(1, TimeUnit.SECONDS));
+
+    assertNotNull(engine.removeListener(engineCallback));
+  }
+
+  private static LocationEngineRequest getRequest(long interval, int priority) {
+    return new LocationEngineRequest.Builder(interval).setPriority(priority).build();
+  }
+}

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/engine/GoogleLocationEngineImplTest.java

@@ -0,0 +1,66 @@
+package com.mapbox.mapboxsdk.location.engine;
+
+import android.app.PendingIntent;
+
+import com.google.android.gms.location.FusedLocationProviderClient;
+
+import com.google.android.gms.location.LocationCallback;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.reset;
+
+@RunWith(MockitoJUnitRunner.class)
+public class GoogleLocationEngineImplTest {
+  @Mock
+  private FusedLocationProviderClient fusedLocationProviderClientMock;
+
+  private LocationEngine engine;
+  private GoogleLocationEngineImpl googleLocationEngineImpl;
+
+  @Before
+  public void setUp() {
+    googleLocationEngineImpl = new GoogleLocationEngineImpl(fusedLocationProviderClientMock);
+    engine = new LocationEngineProxy<>(googleLocationEngineImpl);
+  }
+
+  @Test
+  public void removeLocationUpdatesForInvalidListener() {
+    LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class);
+    engine.removeLocationUpdates(callback);
+    verify(fusedLocationProviderClientMock, never()).removeLocationUpdates(any(LocationCallback.class));
+  }
+
+  @Test
+  public void removeLocationUpdatesForPendingIntent() {
+    PendingIntent pendingIntent = mock(PendingIntent.class);
+    engine.removeLocationUpdates(pendingIntent);
+    verify(fusedLocationProviderClientMock, times(1))
+      .removeLocationUpdates(any(PendingIntent.class));
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void getLastLocationNullCallback() {
+    engine.getLastLocation(null);
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void requestLocationUpdatesNullCallback() {
+    engine.requestLocationUpdates(null, null, null);
+  }
+
+  @After
+  public void tearDown() {
+    reset(fusedLocationProviderClientMock);
+    engine = null;
+  }
+}

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/engine/LocationEngineProviderTest.java

@@ -0,0 +1,14 @@
+package com.mapbox.mapboxsdk.location.engine;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LocationEngineProviderTest {
+
+  @Test(expected = NullPointerException.class)
+  public void passNullContext() {
+    LocationEngineProvider.getBestLocationEngine(null, false);
+  }
+}

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/engine/LocationEngineProxyTest.java

@@ -0,0 +1,104 @@
+package com.mapbox.mapboxsdk.location.engine;
+
+import android.location.LocationListener;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LocationEngineProxyTest {
+  @Mock
+  private LocationEngineCallback<LocationEngineResult> callback;
+
+  @Mock
+  private LocationEngineImpl<LocationListener> engineImpl;
+
+  private LocationEngineProxy<LocationListener> locationEngineProxy;
+
+  @Before
+  public void setUp() {
+    locationEngineProxy = new LocationEngineProxy<>(engineImpl);
+  }
+
+  @Test
+  public void testAddListener() {
+    AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport transport =
+      new AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport(callback);
+    when(engineImpl.createListener(callback)).thenReturn(transport);
+
+    LocationListener locationListener = locationEngineProxy.getListener(callback);
+    assertThat(locationListener).isSameAs(transport);
+    assertThat(locationEngineProxy.getListenersCount()).isEqualTo(1);
+  }
+
+  @Test
+  public void testAddListenerTwice() {
+    AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport transport =
+      new AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport(callback);
+    when(engineImpl.createListener(callback)).thenReturn(transport);
+
+    locationEngineProxy.getListener(callback);
+    locationEngineProxy.getListener(callback);
+    assertThat(locationEngineProxy.getListenersCount()).isEqualTo(1);
+  }
+
+  @Test
+  public void testAddTwoListeners() {
+    AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport transport =
+      new AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport(callback);
+    when(engineImpl.createListener(callback)).thenReturn(transport);
+    locationEngineProxy.getListener(callback);
+
+    LocationEngineCallback<LocationEngineResult> anotherCallback = mock(LocationEngineCallback.class);
+    AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport anotherTransport =
+      new AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport(anotherCallback);
+    when(engineImpl.createListener(anotherCallback)).thenReturn(anotherTransport);
+    locationEngineProxy.getListener(anotherCallback);
+    assertThat(locationEngineProxy.getListenersCount()).isEqualTo(2);
+  }
+
+  @Test
+  public void testRemoveListener() {
+    AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport transport =
+      new AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport(callback);
+    when(engineImpl.createListener(callback)).thenReturn(transport);
+    locationEngineProxy.getListener(callback);
+
+    locationEngineProxy.removeListener(callback);
+    assertThat(locationEngineProxy.getListenersCount()).isEqualTo(0);
+  }
+
+  @Test
+  public void testCheckRemovedListener() {
+    AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport transport =
+      new AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport(callback);
+    when(engineImpl.createListener(callback)).thenReturn(transport);
+    locationEngineProxy.getListener(callback);
+
+    LocationEngineCallback<LocationEngineResult> anotherCallback = mock(LocationEngineCallback.class);
+    AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport anotherTransport =
+      new AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport(anotherCallback);
+    when(engineImpl.createListener(anotherCallback)).thenReturn(anotherTransport);
+    locationEngineProxy.getListener(anotherCallback);
+
+    assertThat(locationEngineProxy.removeListener(callback)).isSameAs(transport);
+    assertThat(locationEngineProxy.removeListener(anotherCallback)).isSameAs(anotherTransport);
+  }
+
+  @Test
+  public void testRemoveListenerTwice() {
+    AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport transport =
+      new AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport(callback);
+    when(engineImpl.createListener(callback)).thenReturn(transport);
+    locationEngineProxy.getListener(callback);
+
+    assertThat(locationEngineProxy.removeListener(callback)).isSameAs(transport);
+    assertThat(locationEngineProxy.removeListener(callback)).isNull();
+  }
+}

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/engine/LocationEngineRequestTest.java

@@ -0,0 +1,72 @@
+package com.mapbox.mapboxsdk.location.engine;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LocationEngineRequestTest {
+
+  @Test
+  public void checkDefaultValues() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(1000L).build();
+
+    assertThat(request.getInterval()).isEqualTo(1000L);
+    assertThat(request.getDisplacement()).isEqualTo(0.0f);
+    assertThat(request.getMaxWaitTime()).isEqualTo(0L);
+    assertThat(request.getFastestInterval()).isEqualTo(0L);
+  }
+
+  @Test
+  public void checkBuilder() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(2000L)
+            .setDisplacement(100.0f)
+            .setMaxWaitTime(5000L)
+            .setFastestInterval(500L)
+            .build();
+
+    assertThat(request.getInterval()).isEqualTo(2000L);
+    assertThat(request.getDisplacement()).isEqualTo(100.0f);
+    assertThat(request.getMaxWaitTime()).isEqualTo(5000L);
+    assertThat(request.getFastestInterval()).isEqualTo(500L);
+  }
+
+  @Test
+  public void checkRequestEqual() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(2000L).build();
+    LocationEngineRequest otherRequest = new LocationEngineRequest.Builder(2000L).build();
+
+    assertThat(request).isEqualTo(otherRequest);
+    assertThat(request.hashCode()).isEqualTo(otherRequest.hashCode());
+  }
+
+  @Test
+  public void checkRequestsNotEqual() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(2000L).build();
+    LocationEngineRequest otherRequest = new LocationEngineRequest.Builder(2000L)
+            .setFastestInterval(500L)
+            .build();
+
+    assertThat(request).isNotEqualTo(otherRequest);
+  }
+
+  @Test
+  public void checkRequestsEqualHashCode() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(2000L).build();
+    LocationEngineRequest otherRequest = new LocationEngineRequest.Builder(2000L).build();
+
+    assertThat(request.hashCode()).isEqualTo(otherRequest.hashCode());
+  }
+
+  @Test
+  public void checkRequestsNonEqualHashCode() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(2000L).build();
+    LocationEngineRequest otherRequest = new LocationEngineRequest.Builder(2000L)
+            .setFastestInterval(500L)
+            .build();
+
+    assertThat(request.hashCode()).isNotEqualTo(otherRequest.hashCode());
+  }
+}

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/engine/LocationEngineResultTest.java

@@ -0,0 +1,132 @@
+package com.mapbox.mapboxsdk.location.engine;
+
+import android.content.Intent;
+import android.location.Location;
+import android.location.LocationManager;
+import android.os.Bundle;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.mockito.Mockito.mock;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LocationEngineResultTest {
+
+  private static final double TEST_LAT_LNG = 1.0;
+
+  @Test
+  public void checkNullIntent() {
+    LocationEngineResult result = LocationEngineResult.extractResult(null);
+    assertThat(result).isNull();
+  }
+
+  @Test
+  public void passInvalidIntent() {
+    Intent intent = mock(Intent.class);
+    LocationEngineResult result = LocationEngineResult.extractResult(intent);
+    assertThat(result).isNull();
+  }
+
+  @Test
+  public void passValidIntent() {
+    Location location = mock(Location.class);
+    LocationEngineResult result = LocationEngineResult.extractResult(getValidIntent(location));
+    assertThat(result).isNotNull();
+    assertThat(result.getLastLocation()).isSameAs(location);
+  }
+
+  @Test
+  public void passNullLocation() {
+    Location location = null;
+    LocationEngineResult result = LocationEngineResult.create(location);
+    assertForNullInput(result);
+  }
+
+  @Test
+  public void passNullLocationList() {
+    List<Location> locations = null;
+    LocationEngineResult result = LocationEngineResult.create(locations);
+    assertForNullInput(result);
+  }
+
+  @Test
+  public void passValidLocation() {
+    Location location = getValidLocation();
+    LocationEngineResult result = LocationEngineResult.create(location);
+    assertForValidInput(result);
+  }
+
+  @Test
+  public void passValidLocationList() {
+    List<Location> locations = Collections.singletonList(getValidLocation());
+    LocationEngineResult result = LocationEngineResult.create(locations);
+    assertForValidInput(result);
+  }
+
+  @Test
+  public void passMutableLocationListWithNulls() {
+    List<Location> locations = getLocationsWithNulls();
+    LocationEngineResult result = LocationEngineResult.create(locations);
+    assertForValidInput(result);
+  }
+
+  @Test
+  public void passImmutableLocationListWithNulls() {
+    List<Location> locations = Collections.unmodifiableList(getLocationsWithNulls());
+    LocationEngineResult result = LocationEngineResult.create(locations);
+    assertForValidInput(result);
+  }
+
+  @Test
+  public void passImmutableListWithNullLocation() {
+    List<Location> locations = Collections.singletonList(null);
+    LocationEngineResult result = LocationEngineResult.create(locations);
+    assertThat(result != null);
+    assertThat(result.getLocations().size() == 0);
+  }
+
+  private static List<Location> getLocationsWithNulls() {
+    return new ArrayList<Location>() {
+      {
+        add(null);
+        add(getValidLocation());
+        add(null);
+      }
+    };
+  }
+
+  private static Location getValidLocation() {
+    Location location = mock(Location.class);
+    when(location.getLatitude()).thenReturn(TEST_LAT_LNG);
+    when(location.getLongitude()).thenReturn(TEST_LAT_LNG);
+    return location;
+  }
+
+  private static void assertForNullInput(LocationEngineResult result) {
+    assertThat(result).isNotNull();
+    assertThat(result.getLocations()).isEmpty();
+  }
+
+  private static void assertForValidInput(LocationEngineResult result) {
+    assertThat(result.getLocations()).isNotNull();
+    assertThat(result.getLocations().size()).isEqualTo(1);
+    assertThat(result.getLocations().get(0).getLatitude()).isEqualTo(TEST_LAT_LNG);
+    assertThat(result.getLocations().get(0).getLongitude()).isEqualTo(TEST_LAT_LNG);
+  }
+
+  private static Intent getValidIntent(Location location) {
+    Intent intent = mock(Intent.class);
+    when(intent.hasExtra(LocationManager.KEY_LOCATION_CHANGED)).thenReturn(true);
+    Bundle bundle = mock(Bundle.class);
+    when(bundle.getParcelable(LocationManager.KEY_LOCATION_CHANGED)).thenReturn(location);
+    when(intent.getExtras()).thenReturn(bundle);
+    return intent;
+  }
+}

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/engine/LocationEngineTest.java

@@ -0,0 +1,142 @@
+package com.mapbox.mapboxsdk.location.engine;
+
+import android.location.Location;
+import android.location.LocationListener;
+import android.os.Looper;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.Stubber;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static junit.framework.TestCase.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.doAnswer;
+
+@RunWith(MockitoJUnitRunner.class)
+public class LocationEngineTest {
+  private static final double LATITUDE = 37.7749;
+  private static final double LONGITUDE = 122.4194;
+  private static final long INTERVAL = 1000L;
+
+  @Mock
+  private LocationEngineImpl<LocationListener> locationEngineImpl;
+
+  private LocationEngine engine;
+
+  @Before
+  public void setUp() {
+    engine = new LocationEngineProxy<>(locationEngineImpl);
+  }
+
+  @Test
+  public void getLastLocation() throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(1);
+    final AtomicReference<LocationEngineResult> resultRef = new AtomicReference<>();
+
+    LocationEngineCallback<LocationEngineResult> callback = getCallback(resultRef, latch);
+    final Location location = getMockLocation(LATITUDE, LONGITUDE);
+    final LocationEngineResult expectedResult = getMockEngineResult(location);
+
+    setupDoAnswer(expectedResult).when(locationEngineImpl).getLastLocation(callback);
+
+    engine.getLastLocation(callback);
+    assertTrue(latch.await(5, SECONDS));
+
+    LocationEngineResult result = resultRef.get();
+    assertThat(result).isSameAs(expectedResult);
+    assertThat(result.getLastLocation()).isEqualTo(expectedResult.getLastLocation());
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void getLastLocationNullCallback() {
+    engine.getLastLocation(null);
+  }
+
+  @Test
+  public void requestLocationUpdates() throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(1);
+    final AtomicReference<LocationEngineResult> resultRef = new AtomicReference<>();
+
+    LocationEngineCallback<LocationEngineResult> callback = getCallback(resultRef, latch);
+    final Location location = getMockLocation(LATITUDE, LONGITUDE);
+    final LocationEngineResult expectedResult = getMockEngineResult(location);
+    Looper looper = mock(Looper.class);
+
+    AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport transport =
+      new AndroidLocationEngineImpl.AndroidLocationEngineCallbackTransport(callback);
+    when(locationEngineImpl.createListener(callback)).thenReturn(transport);
+
+    engine.requestLocationUpdates(getRequest(INTERVAL), callback, looper);
+    transport.onLocationChanged(location);
+    assertTrue(latch.await(5, SECONDS));
+
+    LocationEngineResult result = resultRef.get();
+    assertThat(result.getLastLocation()).isEqualTo(expectedResult.getLastLocation());
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void requestLocationUpdatesNullCallback() {
+    engine.requestLocationUpdates(null, null, null);
+  }
+
+  @After
+  public void tearDown() {
+    reset(locationEngineImpl);
+    engine = null;
+  }
+
+  private static Stubber setupDoAnswer(final LocationEngineResult expectedResult) {
+    return doAnswer(new Answer() {
+      @Override
+      public Object answer(InvocationOnMock invocation) {
+        LocationEngineCallback<LocationEngineResult> callback = invocation.getArgument(0);
+        callback.onSuccess(expectedResult);
+        return null;
+      }
+    });
+  }
+
+  private static LocationEngineRequest getRequest(long interval) {
+    return new LocationEngineRequest.Builder(interval).build();
+  }
+
+  private static LocationEngineCallback<LocationEngineResult> getCallback(
+    final AtomicReference<LocationEngineResult> resultRef,
+    final CountDownLatch latch) {
+    return new LocationEngineCallback<LocationEngineResult>() {
+      @Override
+      public void onSuccess(LocationEngineResult result) {
+        resultRef.set(result);
+        latch.countDown();
+      }
+
+      @Override
+      public void onFailure(Exception exception) {
+        exception.printStackTrace();
+      }
+    };
+  }
+
+  private static LocationEngineResult getMockEngineResult(Location location) {
+    return LocationEngineResult.create(location);
+  }
+
+  private static Location getMockLocation(double lat, double lon) {
+    Location location = mock(Location.class);
+    location.setLatitude(lat);
+    location.setLongitude(lon);
+    return location;
+  }
+}

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/engine/MapboxFusedLocationEngineImplAdditionalTest2.java

@@ -0,0 +1,152 @@
+package com.mapbox.mapboxsdk.location.engine;
+
+import android.content.Context;
+import android.location.Criteria;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.location.LocationProvider;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.mockito.stubbing.Answer;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyFloat;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class MapboxFusedLocationEngineImplAdditionalTest2 {
+  private static final long INTERVAL = 1000L;
+  private static final String PROVIDER = "test_provider";
+  private ArrayList<LocationEngineProxy> engines = new ArrayList<>();
+  private LocationManager mockLocationManager;
+  private Location location = new Location(PROVIDER);
+
+  @Before
+  public void setUp() {
+    location = mock(Location.class);
+    when(location.getLatitude()).thenReturn(1.0);
+    when(location.getLongitude()).thenReturn(2.0);
+    Context mockContext = mock(Context.class);
+    mockLocationManager = mock(LocationManager.class);
+    when(mockContext.getSystemService(anyString())).thenReturn(mockLocationManager);
+    List<String> providers = new ArrayList<>();
+    providers.add(PROVIDER);
+    when(mockLocationManager.getAllProviders()).thenReturn(providers);
+    when(mockLocationManager.getBestProvider(any(Criteria.class), anyBoolean()))
+      .thenReturn(LocationManager.GPS_PROVIDER);
+    doAnswer(new Answer<Object>() {
+      @Override
+      public Object answer(InvocationOnMock invocation) {
+        LocationListener listener = (LocationListener) invocation.getArguments()[3];
+        listener.onProviderEnabled(PROVIDER);
+        listener.onStatusChanged(PROVIDER, LocationProvider.AVAILABLE, null);
+        listener.onLocationChanged(location);
+        listener.onProviderDisabled(PROVIDER);
+        return null;
+      }
+    }).when(mockLocationManager)
+      .requestLocationUpdates(anyString(), anyLong(), anyFloat(), any(LocationListener.class), any(Looper.class));
+    engines.add(new LocationEngineProxy<>(new MapboxFusedLocationEngineImpl(mockContext)));
+    engines.add(new LocationEngineProxy<>(new AndroidLocationEngineImpl(mockContext)));
+  }
+
+  @Test
+  public void checkGetLastLocation() throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(engines.size());
+
+    for (LocationEngineProxy engineProxy : engines) {
+      engineProxy.getLastLocation(new LocationEngineCallback<LocationEngineResult>() {
+        @Override
+        public void onSuccess(LocationEngineResult result) {
+        }
+
+        @Override
+        public void onFailure(@NonNull Exception exception) {
+          assertEquals("Last location unavailable", exception.getLocalizedMessage());
+          latch.countDown();
+        }
+      });
+    }
+    assertTrue(latch.await(1, TimeUnit.SECONDS));
+
+    when(mockLocationManager.getLastKnownLocation(anyString())).thenReturn(location);
+    final CountDownLatch latch1 = new CountDownLatch(engines.size());
+
+    for (LocationEngineProxy engineProxy : engines) {
+      engineProxy.getLastLocation(new LocationEngineCallback<LocationEngineResult>() {
+        @Override
+        public void onSuccess(LocationEngineResult result) {
+          List<Location> list = result.getLocations();
+          assertEquals(1, list.size());
+          assertEquals(1.0, list.get(0).getLatitude(), 0);
+          assertEquals(2.0, list.get(0).getLongitude(), 0);
+          latch1.countDown();
+        }
+
+        @Override
+        public void onFailure(@NonNull Exception exception) {
+
+        }
+      });
+
+    }
+    assertTrue(latch1.await(1, TimeUnit.SECONDS));
+
+  }
+
+  @Test
+  public void checkRequestAndRemoveLocationUpdates() throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(engines.size());
+
+    LocationEngineCallback<LocationEngineResult> engineCallback = new LocationEngineCallback<LocationEngineResult>() {
+      @Override
+      public void onSuccess(LocationEngineResult result) {
+        List<Location> list = result.getLocations();
+        assertEquals(1, list.size());
+        assertEquals(1.0, list.get(0).getLatitude(), 0);
+        assertEquals(2.0, list.get(0).getLongitude(), 0);
+        latch.countDown();
+      }
+
+      @Override
+      public void onFailure(@NonNull Exception exception) {
+
+      }
+    };
+
+
+    for (LocationEngineProxy engineProxy : engines) {
+      engineProxy.requestLocationUpdates(getRequest(INTERVAL, LocationEngineRequest.PRIORITY_HIGH_ACCURACY),
+        engineCallback, mock(Looper.class));
+
+      assertTrue(latch.await(1, TimeUnit.SECONDS));
+
+      assertNotNull(engineProxy.removeListener(engineCallback));
+    }
+
+  }
+
+  private static LocationEngineRequest getRequest(long interval, int priority) {
+    return new LocationEngineRequest.Builder(interval).setPriority(priority).build();
+  }
+}

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/location/engine/MapboxFusedLocationEngineImplTest.java

@@ -0,0 +1,176 @@
+package com.mapbox.mapboxsdk.location.engine;
+
+import android.app.PendingIntent;
+import android.content.Context;
+import android.location.Criteria;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.os.Looper;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static junit.framework.TestCase.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyBoolean;
+import static org.mockito.Mockito.anyFloat;
+import static org.mockito.Mockito.anyLong;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.reset;
+
+@RunWith(MockitoJUnitRunner.class)
+public class MapboxFusedLocationEngineImplTest {
+  private static final double LATITUDE = 37.7749;
+  private static final double LONGITUDE = 122.4194;
+
+  @Mock
+  private LocationManager locationManagerMock;
+
+  private LocationEngine engine;
+  private MapboxFusedLocationEngineImpl mapboxFusedLocationEngineImpl;
+
+  @Before
+  public void setUp() {
+    Context context = mock(Context.class);
+    when(context.getSystemService(Context.LOCATION_SERVICE)).thenReturn(locationManagerMock);
+    mapboxFusedLocationEngineImpl = new MapboxFusedLocationEngineImpl(context);
+    engine = new LocationEngineProxy<>(mapboxFusedLocationEngineImpl);
+  }
+
+  @Test
+  public void getLastLocation() throws InterruptedException {
+    final CountDownLatch latch = new CountDownLatch(1);
+    final AtomicReference<LocationEngineResult> resultRef = new AtomicReference<>();
+
+    LocationEngineCallback<LocationEngineResult> callback = getCallback(resultRef, latch);
+    final Location location = getMockLocation(LATITUDE, LONGITUDE);
+    final LocationEngineResult expectedResult = getMockEngineResult(location);
+
+    when(locationManagerMock.getAllProviders()).thenReturn(Arrays.asList("gps", "network"));
+    when(locationManagerMock.getLastKnownLocation(anyString())).thenReturn(location);
+
+    engine.getLastLocation(callback);
+    assertTrue(latch.await(5, SECONDS));
+
+    LocationEngineResult result = resultRef.get();
+    assertThat(result.getLastLocation()).isEqualTo(expectedResult.getLastLocation());
+  }
+
+  @Test
+  public void createListener() {
+    LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class);
+    LocationListener locationListener = mapboxFusedLocationEngineImpl.createListener(callback);
+    Location mockLocation = getMockLocation(LATITUDE, LONGITUDE);
+    locationListener.onLocationChanged(mockLocation);
+    ArgumentCaptor<LocationEngineResult> argument = ArgumentCaptor.forClass(LocationEngineResult.class);
+    verify(callback).onSuccess(argument.capture());
+
+    LocationEngineResult result = argument.getValue();
+    assertThat(result.getLastLocation()).isSameAs(mockLocation);
+  }
+
+  @Test
+  public void requestLocationUpdatesOutdoors() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(10)
+      .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY).build();
+    LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class);
+    Looper looper = mock(Looper.class);
+    when(locationManagerMock.getBestProvider(any(Criteria.class), anyBoolean())).thenReturn("gps");
+    engine.requestLocationUpdates(request, callback, looper);
+    verify(locationManagerMock, times(2)).requestLocationUpdates(anyString(),
+      anyLong(), anyFloat(), any(LocationListener.class), any(Looper.class));
+  }
+
+  @Test
+  public void requestLocationUpdatesIndoors() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(10)
+      .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY).build();
+    LocationEngineCallback<LocationEngineResult> callback = mock(LocationEngineCallback.class);
+    Looper looper = mock(Looper.class);
+    when(locationManagerMock.getBestProvider(any(Criteria.class), anyBoolean())).thenReturn("network");
+    engine.requestLocationUpdates(request, callback, looper);
+    verify(locationManagerMock, times(1)).requestLocationUpdates(anyString(),
+      anyLong(), anyFloat(), any(LocationListener.class), any(Looper.class));
+  }
+
+  @Test
+  public void requestLocationUpdatesOutdoorsWithPendingIntent() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(10)
+      .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY).build();
+    PendingIntent pendingIntent = mock(PendingIntent.class);
+    when(locationManagerMock.getBestProvider(any(Criteria.class), anyBoolean())).thenReturn("gps");
+    engine.requestLocationUpdates(request, pendingIntent);
+    verify(locationManagerMock, times(2)).requestLocationUpdates(anyString(),
+      anyLong(), anyFloat(), any(PendingIntent.class));
+  }
+
+  @Test
+  public void requestLocationUpdatesIndoorsWithPendingIntent() {
+    LocationEngineRequest request = new LocationEngineRequest.Builder(10)
+      .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY).build();
+    PendingIntent pendingIntent = mock(PendingIntent.class);
+    when(locationManagerMock.getBestProvider(any(Criteria.class), anyBoolean())).thenReturn("network");
+    engine.requestLocationUpdates(request, pendingIntent);
+    verify(locationManagerMock, times(1)).requestLocationUpdates(anyString(),
+      anyLong(), anyFloat(), any(PendingIntent.class));
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void getLastLocationNullCallback() {
+    engine.getLastLocation(null);
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void requestLocationUpdatesNullCallback() {
+    engine.requestLocationUpdates(null, null, null);
+  }
+
+  @After
+  public void tearDown() {
+    reset(locationManagerMock);
+    engine = null;
+  }
+
+  private static LocationEngineCallback<LocationEngineResult> getCallback(
+    final AtomicReference<LocationEngineResult> resultRef,
+    final CountDownLatch latch) {
+    return new LocationEngineCallback<LocationEngineResult>() {
+      @Override
+      public void onSuccess(LocationEngineResult result) {
+        resultRef.set(result);
+        latch.countDown();
+      }
+
+      @Override
+      public void onFailure(Exception exception) {
+        exception.printStackTrace();
+      }
+    };
+  }
+
+  private static LocationEngineResult getMockEngineResult(Location location) {
+    return LocationEngineResult.create(location);
+  }
+
+  private static Location getMockLocation(double lat, double lon) {
+    Location location = mock(Location.class);
+    location.setLatitude(lat);
+    location.setLongitude(lon);
+    return location;
+  }
+}

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/module/telemetry/MapEventFactoryTest.java

@@ -1,5 +1,3 @@
-package com.mapbox.mapboxsdk.module.telemetry;
-
 import android.os.Build;
 import android.os.Bundle;
 
@@ -14,7 +12,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 
-import static com.mapbox.mapboxsdk.module.telemetry.PerformanceEvent.PerformanceAttribute;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.mockito.Mockito.mock;

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/module/telemetry/SchemaTest.java

@@ -1,5 +1,3 @@
-package com.mapbox.mapboxsdk.module.telemetry;
-
 import com.google.gson.Gson;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;

platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/telemetry/HttpTransportTest.java

@@ -1,20 +0,0 @@
-package com.mapbox.mapboxsdk.telemetry;
-
-import com.mapbox.android.telemetry.TelemetryUtils;
-
-import org.junit.Test;
-
-import static junit.framework.Assert.assertEquals;
-
-public class HttpTransportTest {
-
-  @Test
-  public void testNonAsciiUserAgent() {
-
-    final String swedishUserAgent = "Sveriges Fjäll/1.0/1 MapboxEventsAndroid/4.0.0-SNAPSHOT";
-    final String asciiVersion = "Sveriges Fj?ll/1.0/1 MapboxEventsAndroid/4.0.0-SNAPSHOT";
-
-    assertEquals("asciiVersion and swedishUserAgent should match", asciiVersion,
-      TelemetryUtils.toHumanReadableAscii(swedishUserAgent));
-  }
-}