@josuelmm/cordova-background-geolocation 2.3.5

package/android/common/src/androidTest/java/com/marianhello/bgloc/ContentProviderLocationDAOTest.java

@@ -0,0 +1,437 @@
+package com.marianhello.bgloc;
+
+import android.database.sqlite.SQLiteDatabase;
+import android.location.Location;
+
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.data.LocationDAO;
+import com.marianhello.bgloc.data.provider.ContentProviderLocationDAO;
+import com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper;
+import com.marianhello.bgloc.test.LocationProviderTestCase;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+import static androidx.test.platform.app.InstrumentationRegistry.getContext;
+import static com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry.SQL_DROP_LOCATION_TABLE;
+import static junit.framework.Assert.assertEquals;
+
+public class ContentProviderLocationDAOTest extends LocationProviderTestCase {
+    public void deleteDatabase() {
+        SQLiteOpenHelper dbHelper = new SQLiteOpenHelper(getContext());
+        SQLiteDatabase db = dbHelper.getWritableDatabase();
+        dbHelper.execAndLogSql(db, SQL_DROP_LOCATION_TABLE);
+        dbHelper.onCreate(db);
+    }
+
+    @Before
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        deleteDatabase();
+    }
+
+    @Test
+    public void testPersistLocation() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        Location location = new Location("fake");
+        location.setAccuracy(200);
+        location.setAltitude(900);
+        location.setBearing(2);
+        location.setLatitude(40.21);
+        location.setLongitude(23.45);
+        location.setSpeed(20);
+        location.setProvider("test");
+        location.setTime(1000);
+        BackgroundLocation bgLocation = BackgroundLocation.fromLocation(location);
+
+        dao.persistLocation(bgLocation);
+
+        ArrayList<BackgroundLocation> locations = new ArrayList(dao.getAllLocations());
+        assertEquals(1, locations.size());
+
+        BackgroundLocation storedLocation = locations.get(0);
+        assertEquals(200, storedLocation.getAccuracy(), 0);
+        assertEquals(900, storedLocation.getAltitude(), 0);
+        assertEquals(2, storedLocation.getBearing(), 0);
+        assertEquals(40.21, storedLocation.getLatitude(), 0);
+        assertEquals(23.45, storedLocation.getLongitude(), 0);
+        assertEquals(20, storedLocation.getSpeed(), 0);
+        assertEquals("test", storedLocation.getProvider(), "test");
+        assertEquals(1000, storedLocation.getTime(), 0);
+        junit.framework.Assert.assertFalse(storedLocation.hasMockLocationsEnabled());
+        junit.framework.Assert.assertFalse(storedLocation.areMockLocationsEnabled());
+        junit.framework.Assert.assertTrue(storedLocation.hasIsFromMockProvider()); // because setIsFromMockProvider is called in constructor
+        junit.framework.Assert.assertFalse(storedLocation.isFromMockProvider());
+    }
+
+    @Test
+    public void testPersistLocationIsMock() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        BackgroundLocation bgLocation = new BackgroundLocation();
+        bgLocation.setMockLocationsEnabled(true);
+        bgLocation.setIsFromMockProvider(true);
+
+        dao.persistLocation(bgLocation);
+
+        ArrayList<BackgroundLocation> locations = new ArrayList(dao.getAllLocations());
+        assertEquals(1, locations.size());
+
+        BackgroundLocation storedLocation = locations.get(0);
+        junit.framework.Assert.assertTrue(storedLocation.hasMockLocationsEnabled());
+        junit.framework.Assert.assertTrue(storedLocation.areMockLocationsEnabled());
+        junit.framework.Assert.assertTrue(storedLocation.hasIsFromMockProvider());
+        junit.framework.Assert.assertTrue(storedLocation.isFromMockProvider());
+    }
+
+    @Test
+    public void testDeleteLocationById() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        BackgroundLocation bgLocation = BackgroundLocation.fromLocation(new Location("fake"));
+        Collection<BackgroundLocation> locations = null;
+
+        Long locationId = dao.persistLocation(bgLocation);
+
+        locations = dao.getAllLocations();
+        assertEquals(1, locations.size());
+
+        dao.deleteLocationById(locationId);
+
+        locations = dao.getValidLocations();
+        assertEquals(0, locations.size());
+    }
+
+    @Test
+    public void testDeleteAllLocations() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+        Collection<BackgroundLocation> locations = null;
+
+        for (int i = 0; i < 10; i++) {
+            dao.persistLocation(BackgroundLocation.fromLocation(new Location("fake")));
+        }
+
+        locations = dao.getValidLocations();
+        assertEquals(10, locations.size());
+
+        dao.deleteAllLocations();
+
+        locations = dao.getValidLocations();
+        assertEquals(0, locations.size());
+    }
+
+    @Test
+    public void testGetAllLocations() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        Location location = null;
+        BackgroundLocation bgLocation = null;
+
+        for (int i = 0; i < 10; i++) {
+            location = new Location("fake");
+            location.setAccuracy(200 + i);
+            location.setAltitude(900 + i);
+            location.setBearing(2 + i);
+            location.setLatitude(40.21 + i);
+            location.setLongitude(23.45 + i);
+            location.setSpeed(20 + i);
+            location.setProvider("test");
+            location.setTime(1000 + i);
+            bgLocation = BackgroundLocation.fromLocation(location);
+            dao.persistLocation(bgLocation);
+        }
+
+        Collection<BackgroundLocation> locations = dao.getAllLocations();
+        Iterator<BackgroundLocation> it = locations.iterator();
+        BackgroundLocation storedLocation = null;
+        for (int i = 0; i < 10; i++) {
+            storedLocation = it.next();
+            assertEquals(200 + i, storedLocation.getAccuracy(), 0);
+            assertEquals(900 + i, storedLocation.getAltitude(), 0);
+            assertEquals(2 + i, storedLocation.getBearing(), 0);
+            assertEquals(40.21 + i, storedLocation.getLatitude(), 0);
+            assertEquals(23.45 + i,storedLocation.getLongitude(), 0);
+            assertEquals(20 + i, storedLocation.getSpeed(), 0);
+            assertEquals("test", storedLocation.getProvider());
+            assertEquals(1000 + i, storedLocation.getTime(), 0);
+        }
+    }
+
+    @Test
+    public void testPersistLocationWithRowLimit() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        int maxRows = 100;
+
+        for (int i = 0; i < maxRows * 2; i++) {
+            dao.persistLocation(BackgroundLocation.fromLocation(new Location("fake")), maxRows);
+        }
+
+        Collection<BackgroundLocation> locations = dao.getAllLocations();
+        assertEquals(maxRows, locations.size());
+    }
+
+    @Test
+    public void testShouldReplaceOldLocation() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        dao.persistLocation(BackgroundLocation.fromLocation(new Location("old")), 1);
+        dao.persistLocation(BackgroundLocation.fromLocation(new Location("new")), 1);
+
+        Collection<BackgroundLocation> locations = dao.getAllLocations();
+        assertEquals(1, locations.size());
+        assertEquals("new", locations.iterator().next().getProvider());
+    }
+
+    @Test
+    public void testPersistLocationWithRowLimitWhenMaxRowsReduced() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        int maxRowsRun[] = {100, 10};
+
+        for (int i = 0; i < maxRowsRun.length; i++) {
+            int maxRows = maxRowsRun[i];
+            for (int j = 0; j < maxRows * 2; j++) {
+                dao.persistLocation(BackgroundLocation.fromLocation(new Location("fake")), maxRows);
+            }
+            Collection<BackgroundLocation> locations = dao.getAllLocations();
+            assertEquals(maxRows, locations.size());
+        }
+
+        Long locationId = dao.persistLocation(BackgroundLocation.fromLocation(new Location("fake")));
+        assertEquals(locationId, Long.valueOf(101));
+    }
+
+    @Test
+    public void testPersistLocationWithBatchId() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        BackgroundLocation location = new BackgroundLocation();
+        location.setBatchStartMillis(1000L);
+        dao.persistLocation(location);
+        ArrayList<BackgroundLocation> locations = new ArrayList(dao.getAllLocations());
+        assertEquals(Long.valueOf(1000L), locations.get(0).getBatchStartMillis());
+    }
+
+    @Test
+    public void testGetLocationsForSyncCount() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        BackgroundLocation location;
+        for (int i = 1; i < 100; i++) {
+            location = new BackgroundLocation();
+            if ((i % 3) == 0) {
+                // exactly 33 locations (out of 99) should be eligible for sync for given batch id 1000
+                location.setBatchStartMillis(1000L);
+                location.setStatus(BackgroundLocation.SYNC_PENDING);
+            } else if ((i % 2) == 0) {
+                // exactly 33 locations as deleted
+                location.setStatus(BackgroundLocation.DELETED);
+            } else {
+                location.setStatus(BackgroundLocation.SYNC_PENDING);
+            }
+            dao.persistLocation(location);
+        }
+
+        assertEquals(66, dao.getValidLocations().size());
+        assertEquals(99, dao.getAllLocations().size());
+        assertEquals(66L, dao.getLocationsForSyncCount(10001L));
+        assertEquals(33L, dao.getLocationsForSyncCount(1000L));
+    }
+
+    @Test
+    public void testGetLocationById() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        Location location = null;
+        BackgroundLocation bgLocation = null;
+
+        for (int i = 0; i < 10; i++) {
+            location = new Location("fake");
+            location.setAccuracy(200 + i);
+            location.setAltitude(900 + i);
+            location.setBearing(2 + i);
+            location.setLatitude(40.21 + i);
+            location.setLongitude(23.45 + i);
+            location.setSpeed(20 + i);
+            location.setProvider("test");
+            location.setTime(1000 + i);
+            bgLocation = BackgroundLocation.fromLocation(location);
+            dao.persistLocation(bgLocation);
+        }
+
+        BackgroundLocation pending = dao.getLocationById(2);
+        assertEquals(Long.valueOf(2), pending.getLocationId());
+    }
+
+    @Test
+    public void testGetFirstPendingLocation() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        BackgroundLocation location = null;
+
+        for (int i = 1; i <= 5; i++) {
+            location = new BackgroundLocation();
+            location.setProvider("fake");
+            location.setAccuracy(200 + i);
+            location.setAltitude(900 + i);
+            location.setBearing(2 + i);
+            location.setLatitude(40.21 + i);
+            location.setLongitude(23.45 + i);
+            location.setSpeed(20 + i);
+            location.setProvider("test");
+            location.setTime(1000 + i);
+            if (i <= 3) {
+                location.setStatus(BackgroundLocation.DELETED);
+            }
+
+            dao.persistLocation(location);
+        }
+
+        BackgroundLocation pending = dao.getFirstUnpostedLocation();
+        assertEquals(Long.valueOf(4), pending.getLocationId());
+    }
+
+    @Test
+    public void testGetNextPendingLocation() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        BackgroundLocation location = null;
+
+        for (int i = 1; i <= 5; i++) {
+            location = new BackgroundLocation();
+            location.setProvider("fake");
+            location.setAccuracy(200 + i);
+            location.setAltitude(900 + i);
+            location.setBearing(2 + i);
+            location.setLatitude(40.21 + i);
+            location.setLongitude(23.45 + i);
+            location.setSpeed(20 + i);
+            location.setProvider("test");
+            location.setTime(1000 + i);
+            if (i <= 3) {
+                location.setStatus(BackgroundLocation.DELETED);
+            }
+
+            dao.persistLocation(location);
+        }
+
+        BackgroundLocation pending = dao.getNextUnpostedLocation(4);
+        assertEquals(Long.valueOf(5), pending.getLocationId());
+    }
+
+    @Test
+    public void testGetPendingLocationsCount() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        BackgroundLocation location = null;
+
+        for (int i = 0; i < 5; i++) {
+            location = new BackgroundLocation();
+            location.setProvider("fake");
+            location.setAccuracy(200 + i);
+            location.setAltitude(900 + i);
+            location.setBearing(2 + i);
+            location.setLatitude(40.21 + i);
+            location.setLongitude(23.45 + i);
+            location.setSpeed(20 + i);
+            location.setProvider("test");
+            location.setTime(1000 + i);
+            if (i < 3) {
+                location.setStatus(BackgroundLocation.DELETED);
+            }
+
+            dao.persistLocation(location);
+        }
+
+        assertEquals(2, dao.getUnpostedLocationsCount());
+    }
+
+    @Test
+    public void testDeleteFirstPendingLocation() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        BackgroundLocation location = null;
+
+        for (int i = 1; i <= 5; i++) {
+            location = new BackgroundLocation();
+            location.setProvider("fake");
+            location.setAccuracy(200 + i);
+            location.setAltitude(900 + i);
+            location.setBearing(2 + i);
+            location.setLatitude(40.21 + i);
+            location.setLongitude(23.45 + i);
+            location.setSpeed(20 + i);
+            location.setProvider("test");
+            location.setTime(1000 + i);
+            if (i <= 3) {
+                location.setStatus(BackgroundLocation.DELETED);
+            }
+
+            dao.persistLocation(location);
+        }
+
+        BackgroundLocation deleted = dao.deleteFirstUnpostedLocation();
+        assertEquals(Long.valueOf(4), deleted.getLocationId());
+    }
+
+    @Test
+    public void testDeletePendingLocations() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        BackgroundLocation location = null;
+
+        for (int i = 0; i < 5; i++) {
+            location = new BackgroundLocation();
+            location.setProvider("fake");
+            location.setAccuracy(200 + i);
+            location.setAltitude(900 + i);
+            location.setBearing(2 + i);
+            location.setLatitude(40.21 + i);
+            location.setLongitude(23.45 + i);
+            location.setSpeed(20 + i);
+            location.setProvider("test");
+            location.setTime(1000 + i);
+            if (i < 3) {
+                location.setStatus(BackgroundLocation.DELETED);
+            }
+
+            dao.persistLocation(location);
+        }
+
+        dao.deleteUnpostedLocations();
+        assertEquals(0, dao.getUnpostedLocationsCount());
+        assertEquals(2, dao.getLocationsForSyncCount(0));
+    }
+
+    @Test
+    public void testPersistLocationForSync() {
+        LocationDAO dao = new ContentProviderLocationDAO(getContext());
+
+        BackgroundLocation location = new BackgroundLocation();
+        location.setProvider("fake");
+        location.setAccuracy(200);
+        location.setAltitude(900);
+        location.setBearing(2);
+        location.setLatitude(40.21);
+        location.setLongitude(23.45);
+        location.setSpeed(20);
+        location.setProvider("test");
+        location.setTime(1000);
+
+        long locationId = dao.persistLocation(location);
+        location.setLocationId(locationId);
+        assertEquals(1, dao.getUnpostedLocationsCount());
+        assertEquals(0, dao.getLocationsForSyncCount(0));
+
+        dao.persistLocationForSync(location, 100);
+        assertEquals(0, dao.getUnpostedLocationsCount());
+        assertEquals(1, dao.getLocationsForSyncCount(0));
+    }
+}

package/android/common/src/androidTest/java/com/marianhello/bgloc/DBLogReaderTest.java

@@ -0,0 +1,95 @@
+package com.marianhello.bgloc;
+
+import android.content.Context;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.SmallTest;
+
+import com.marianhello.logging.DBLogReader;
+import com.marianhello.logging.LogEntry;
+import com.marianhello.logging.LoggerManager;
+
+import junit.framework.Assert;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.slf4j.Logger;
+import org.slf4j.event.Level;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collection;
+
+import ch.qos.logback.classic.LoggerContext;
+import ch.qos.logback.core.CoreConstants;
+import ch.qos.logback.core.android.CommonPathUtil;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class DBLogReaderTest {
+    private static final String TAG = "DBLogReaderTest";
+
+    @Before
+    public void deleteDatabase() {
+        LoggerManager.disableDBLogging();
+        String packageName = null;
+        LoggerContext context = (LoggerContext) org.slf4j.LoggerFactory.getILoggerFactory();
+
+        if (context != null) {
+            packageName = context.getProperty(CoreConstants.PACKAGE_NAME_KEY);
+        }
+
+        if (!(packageName == null || packageName.length() == 0)) {
+            File dbfile = new File(CommonPathUtil.getDatabaseDirectoryPath(packageName), DBLogReader.DB_FILENAME);
+            Context ctx = InstrumentationRegistry.getTargetContext();
+            ctx.deleteDatabase(dbfile.getPath());
+        }
+    }
+
+    @Test
+    public void testReadLogEntriesWithLimit() {
+        LoggerManager.enableDBLogging();
+        Logger logger = LoggerManager.getLogger(DBLogReaderTest.class);
+
+        for (int i = 0; i < 100; i++) {
+            logger.debug("Message #" + i);
+        }
+
+        DBLogReader logReader = new DBLogReader();
+        Collection<LogEntry> entries = logReader.getEntries(10, 0, Level.DEBUG);
+        Assert.assertEquals(10, entries.size());
+    }
+
+    @Test
+    public void testReadLogEntriesWithOffset() {
+        LoggerManager.enableDBLogging();
+        Logger logger = LoggerManager.getLogger(DBLogReaderTest.class);
+
+        for (int i = 0; i < 100; i++) {
+            logger.debug("Message #" + i);
+        }
+
+        DBLogReader logReader = new DBLogReader();
+        ArrayList<LogEntry> entries = (ArrayList) logReader.getEntries(10, 0, Level.DEBUG);
+        LogEntry lastEntry = entries.get(entries.size() - 1);
+        entries = (ArrayList) logReader.getEntries(10, lastEntry.getId(), Level.DEBUG);
+        Assert.assertEquals(lastEntry.getId() - 1, entries.get(0).getId().intValue());
+    }
+
+    @Test
+    public void testReadLogEntriesWithOffsetAsc() {
+        LoggerManager.enableDBLogging();
+        Logger logger = LoggerManager.getLogger(DBLogReaderTest.class);
+
+        for (int i = 0; i < 100; i++) {
+            logger.debug("Message #" + i);
+        }
+
+        DBLogReader logReader = new DBLogReader();
+        ArrayList<LogEntry> entries = (ArrayList) logReader.getEntries(10, 0, Level.DEBUG);
+        LogEntry lastEntry = entries.get(entries.size() - 1);
+        entries = (ArrayList) logReader.getEntries(-10, lastEntry.getId(), Level.DEBUG);
+        Assert.assertEquals(lastEntry.getId() + 1, entries.get(0).getId().intValue());
+    }
+}

package/android/common/src/androidTest/java/com/marianhello/bgloc/LocationContentProviderTest.java

@@ -0,0 +1,159 @@
+package com.marianhello.bgloc;
+
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.test.RenamingDelegatingContext;
+import android.test.mock.MockContentResolver;
+
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.data.provider.LocationContentProvider;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry;
+import com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper;
+import com.marianhello.bgloc.test.LocationProviderTestCase;
+import com.marianhello.bgloc.test.TestConstants;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+import static com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry.SQL_DROP_LOCATION_TABLE;
+
+public class LocationContentProviderTest extends LocationProviderTestCase {
+
+    private MockContentResolver mResolver;
+    private final Uri mContentUri;
+
+    public LocationContentProviderTest() {
+        super();
+        mContentUri = LocationContentProvider.getContentUri(TestConstants.Authority);
+    }
+
+    public void deleteDatabase() {
+        // TODO: investigate why prefix is not automatically used when deleteDatabase
+        RenamingDelegatingContext context = ((RenamingDelegatingContext) getMockContext().getBaseContext());
+
+        SQLiteOpenHelper dbHelper = new SQLiteOpenHelper(context);
+        SQLiteDatabase db = dbHelper.getWritableDatabase();
+        dbHelper.execAndLogSql(db, SQL_DROP_LOCATION_TABLE);
+        dbHelper.onCreate(db);
+    }
+
+    @Before
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        mResolver = getMockContentResolver();
+        deleteDatabase();
+    }
+
+    @Test
+    public void testResolveProvider() {
+        Cursor cursor = mResolver.query(mContentUri, null, null, null,null);
+        Assert.assertNotNull(cursor);
+        cursor.close();
+    }
+
+    @Test
+     public void testShouldCreateAndRetrieveLocation() {
+        BackgroundLocation location = new BackgroundLocation();
+        location.setAccuracy(200);
+        location.setAltitude(900);
+        location.setBearing(2);
+        location.setLatitude(40.21);
+        location.setLongitude(23.45);
+        location.setSpeed(20);
+        location.setProvider("test");
+        location.setTime(1000);
+
+        createLocation(location);
+
+        Cursor cursor = mResolver.query(mContentUri, null, null, null,null);
+        assertEquals(1, cursor.getCount());
+        assertTrue(cursor.moveToFirst());
+
+        assertEquals(200, cursor.getFloat(cursor.getColumnIndex(LocationEntry.COLUMN_NAME_ACCURACY)), 0);
+        assertEquals(900, cursor.getDouble(cursor.getColumnIndex(LocationEntry.COLUMN_NAME_ALTITUDE)), 0);
+        assertEquals(2, cursor.getFloat(cursor.getColumnIndex(LocationEntry.COLUMN_NAME_BEARING)), 0);
+        assertEquals(40.21, cursor.getDouble(cursor.getColumnIndex(LocationEntry.COLUMN_NAME_LATITUDE)), 0);
+        assertEquals(23.45, cursor.getDouble(cursor.getColumnIndex(LocationEntry.COLUMN_NAME_LONGITUDE)), 0);
+        assertEquals(20, cursor.getFloat(cursor.getColumnIndex(LocationEntry.COLUMN_NAME_SPEED)), 0);
+        assertEquals("test", cursor.getString(cursor.getColumnIndex(LocationEntry.COLUMN_NAME_PROVIDER)));
+        assertEquals(1000, cursor.getLong(cursor.getColumnIndex(LocationEntry.COLUMN_NAME_TIME)), 0);
+
+        cursor.close();
+    }
+
+    @Test
+    public void testShouldDeleteSingleLocation() {
+        BackgroundLocation location = new BackgroundLocation();
+        location.setAccuracy(200);
+        location.setAltitude(900);
+        location.setBearing(2);
+        location.setLatitude(40.21);
+        location.setLongitude(23.45);
+        location.setSpeed(20);
+        location.setProvider("test");
+        location.setTime(1000);
+
+        Uri locationUri = createLocation(location);
+        int rowsDeleted = mResolver.delete(locationUri, null, null);
+
+        assertEquals(1, rowsDeleted);
+    }
+
+    @Test
+    public void testShouldDeleteMultipleLocations() {
+        ArrayList<Uri> locationUris = new ArrayList<Uri>();
+
+        for (int i = 1; i <= 2; i++) {
+            BackgroundLocation location = new BackgroundLocation();
+            location.setAccuracy(200);
+            location.setAltitude(900);
+            location.setBearing(2);
+            location.setLatitude(40.21);
+            location.setLongitude(23.45);
+            location.setSpeed(20);
+            location.setProvider("test");
+            location.setTime(1000);
+
+            Uri locationUri = createLocation(location);
+            locationUris.add(locationUri);
+        }
+
+        int rowsDeleted = mResolver.delete(mContentUri, null, null);
+        assertEquals(2, rowsDeleted);
+    }
+
+    @Test
+    public void testShouldUpdateSingleLocation() {
+        BackgroundLocation location = new BackgroundLocation();
+        location.setAccuracy(200);
+        location.setAltitude(900);
+        location.setBearing(2);
+        location.setLatitude(40.21);
+        location.setLongitude(23.45);
+        location.setSpeed(20);
+        location.setProvider("test");
+        location.setTime(1000);
+
+        Uri locationUri = createLocation(location);
+
+        location.setProvider("new test");
+
+        int rowsUpdated = mResolver.update(locationUri, location.toContentValues(), null, null);
+        assertEquals(1, rowsUpdated);
+
+        Cursor cursor = mResolver.query(locationUri, null, null, null,null);
+        assertEquals(1, cursor.getCount());
+        assertTrue(cursor.moveToFirst());
+
+        assertEquals("new test", cursor.getString(cursor.getColumnIndex(LocationEntry.COLUMN_NAME_PROVIDER)));
+    }
+
+    private Uri createLocation(BackgroundLocation location) {
+        return mResolver.insert(mContentUri, location.toContentValues());
+    }
+}