fix #2211: remove application-database indirection

6 files changed, 60 insertions, 78 deletions

diff --git a/tests/src/cgeo/geocaching/cgDataTest.java b/tests/src/cgeo/geocaching/cgDataTest.java
index 9d1a8e2..f4b71f3 100644
--- a/tests/src/cgeo/geocaching/cgDataTest.java
+++ b/tests/src/cgeo/geocaching/cgDataTest.java
@@ -18,7 +18,6 @@ public class cgDataTest extends CGeoTestCase {
 
     public static void testStoredLists() {
 
-        cgeoapplication app = cgeoapplication.getInstance();
         int listId1 = StoredList.STANDARD_LIST_ID;
         int listId2 = StoredList.STANDARD_LIST_ID;
 
@@ -32,11 +31,11 @@ public class cgDataTest extends CGeoTestCase {
         try {
 
             // create lists
-            listId1 = app.createList("cgData Test");
+            listId1 = cgData.createList("cgData Test");
             assertTrue(listId1 > StoredList.STANDARD_LIST_ID);
-            listId2 = app.createList("cgDataTest");
+            listId2 = cgData.createList("cgDataTest");
             assertTrue(listId2 > StoredList.STANDARD_LIST_ID);
-            assertTrue(app.getLists().size() >= 2);
+            assertTrue(cgData.getLists().size() >= 2);
 
             cache1.setDetailed(true);
             cache1.setListId(listId1);
@@ -44,33 +43,33 @@ public class cgDataTest extends CGeoTestCase {
             cache2.setListId(listId1);
 
             // save caches to DB (cache1=listId1, cache2=listId1)
-            app.saveCache(cache1, LoadFlags.SAVE_ALL);
-            app.saveCache(cache2, LoadFlags.SAVE_ALL);
-            assertTrue(cgeoapplication.getAllCachesCount() >= 2);
+            cgData.saveCache(cache1, LoadFlags.SAVE_ALL);
+            cgData.saveCache(cache2, LoadFlags.SAVE_ALL);
+            assertTrue(cgData.getAllCachesCount() >= 2);
 
             // rename list (cache1=listId1, cache2=listId1)
-            assertEquals(1, app.renameList(listId1, "cgData Test (renamed)"));
+            assertEquals(1, cgData.renameList(listId1, "cgData Test (renamed)"));
 
             // get list
-            StoredList list1 = app.getList(listId1);
+            StoredList list1 = cgData.getList(listId1);
             assertEquals("cgData Test (renamed)", list1.title);
 
             // move to list (cache1=listId2, cache2=listId2)
-            app.moveToList(Collections.singletonList(cache1), listId2);
-            assertEquals(1, app.getAllStoredCachesCount(CacheType.ALL, listId2));
+            cgData.moveToList(Collections.singletonList(cache1), listId2);
+            assertEquals(1, cgData.getAllStoredCachesCount(CacheType.ALL, listId2));
 
             // remove list (cache1=listId2, cache2=listId2)
-            assertTrue(app.removeList(listId1));
+            assertTrue(cgData.removeList(listId1));
 
             // mark dropped (cache1=1, cache2=0)
-            app.markDropped(Collections.singletonList(cache2));
+            cgData.markDropped(Collections.singletonList(cache2));
 
             // mark stored (cache1=1, cache2=listId2)
-            app.markStored(Collections.singletonList(cache2), listId2);
-            assertEquals(2, app.getAllStoredCachesCount(CacheType.ALL, listId2));
+            cgData.moveToList(Collections.singletonList(cache2), listId2);
+            assertEquals(2, cgData.getAllStoredCachesCount(CacheType.ALL, listId2));
 
             // drop stored (cache1=0, cache2=0)
-            app.removeList(listId2);
+            cgData.removeList(listId2);
 
         } finally {
 
@@ -78,33 +77,30 @@ public class cgDataTest extends CGeoTestCase {
             Set<String> geocodes = new HashSet<String>();
             geocodes.add(cache1.getGeocode());
             geocodes.add(cache2.getGeocode());
-            app.removeCaches(geocodes, LoadFlags.REMOVE_ALL);
+            cgData.removeCaches(geocodes, LoadFlags.REMOVE_ALL);
 
             // remove list
-            app.removeList(listId1);
-            app.removeList(listId2);
+            cgData.removeList(listId1);
+            cgData.removeList(listId2);
         }
     }
 
     // Check that queries don't throw an exception (see issue #1429).
     public static void testLoadWaypoints() {
         final Viewport viewport = new Viewport(new Geopoint(-1, -2), new Geopoint(3, 4));
-        final cgeoapplication app = cgeoapplication.getInstance();
-        app.getWaypointsInViewport(viewport, false, false, CacheType.ALL);
-        app.getWaypointsInViewport(viewport, false, true, CacheType.ALL);
-        app.getWaypointsInViewport(viewport, true, false, CacheType.ALL);
-        app.getWaypointsInViewport(viewport, true, true, CacheType.ALL);
-        app.getWaypointsInViewport(viewport, false, false, CacheType.TRADITIONAL);
-        app.getWaypointsInViewport(viewport, false, true, CacheType.TRADITIONAL);
-        app.getWaypointsInViewport(viewport, true, false, CacheType.TRADITIONAL);
-        app.getWaypointsInViewport(viewport, true, true, CacheType.TRADITIONAL);
+        cgData.loadWaypoints(viewport, false, false, CacheType.ALL);
+        cgData.loadWaypoints(viewport, false, true, CacheType.ALL);
+        cgData.loadWaypoints(viewport, true, false, CacheType.ALL);
+        cgData.loadWaypoints(viewport, true, true, CacheType.ALL);
+        cgData.loadWaypoints(viewport, false, false, CacheType.TRADITIONAL);
+        cgData.loadWaypoints(viewport, false, true, CacheType.TRADITIONAL);
+        cgData.loadWaypoints(viewport, true, false, CacheType.TRADITIONAL);
+        cgData.loadWaypoints(viewport, true, true, CacheType.TRADITIONAL);
     }
 
     // Check that saving a cache and trackable without logs works (see #2199)
     public static void testSaveWithoutLogs() {
 
-        cgeoapplication app = cgeoapplication.getInstance();
-
         final String GEOCODE_CACHE = "TEST";
 
         // create cache and trackable
@@ -118,21 +114,19 @@ public class cgDataTest extends CGeoTestCase {
         cache.setInventory(inventory);
 
         try {
-            app.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
-            final cgCache loadedCache = app.loadCache(GEOCODE_CACHE, LoadFlags.LOAD_ALL_DB_ONLY);
+            cgData.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
+            final cgCache loadedCache = cgData.loadCache(GEOCODE_CACHE, LoadFlags.LOAD_ALL_DB_ONLY);
             assertNotNull("Cache was not saved!", loadedCache);
             assertEquals(1, loadedCache.getInventory().size());
         } finally {
-            app.removeCache(GEOCODE_CACHE, LoadFlags.REMOVE_ALL);
+            cgData.removeCache(GEOCODE_CACHE, LoadFlags.REMOVE_ALL);
         }
     }
 
     // Loading logs for an empty geocode should return an empty list, not null!
     public static void testLoadLogsFromEmptyGeocode() {
 
-        cgeoapplication app = cgeoapplication.getInstance();
-
-        List<LogEntry> logs = app.loadLogs("");
+        List<LogEntry> logs = cgData.loadLogs("");
 
         assertNotNull("Logs must not be null", logs);
         assertEquals("Logs from empty geocode must be empty", 0, logs.size());
diff --git a/tests/src/cgeo/geocaching/cgeoApplicationTest.java b/tests/src/cgeo/geocaching/cgeoApplicationTest.java
index f7d3158..32cbe40 100644
--- a/tests/src/cgeo/geocaching/cgeoApplicationTest.java
+++ b/tests/src/cgeo/geocaching/cgeoApplicationTest.java
@@ -109,7 +109,7 @@ public class cgeoApplicationTest extends CGeoTestCase {
         if (Settings.isPremiumMember() || search.getError() == null) {
             assertEquals(1, search.getGeocodes().size());
             assertTrue(search.getGeocodes().contains(geocode));
-            return cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
+            return cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
         }
         assertEquals(0, search.getGeocodes().size());
         return null;
@@ -279,8 +279,7 @@ public class cgeoApplicationTest extends CGeoTestCase {
             SearchResult search = ConnectorFactory.searchByViewport(viewport, tokens);
             assertNotNull(search);
             assertTrue(search.getGeocodes().contains(mockedCache.getGeocode()));
-
-            cgCache parsedCache = cgeoapplication.getInstance().loadCache(mockedCache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB);
+            cgCache parsedCache = cgData.loadCache(mockedCache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB);
 
             assertEquals(Settings.isPremiumMember(), mockedCache.getCoords().equals(parsedCache.getCoords()));
             assertEquals(Settings.isPremiumMember(), parsedCache.isReliableLatLon());
@@ -292,8 +291,7 @@ public class cgeoApplicationTest extends CGeoTestCase {
             search = ConnectorFactory.searchByViewport(viewport, tokens);
             assertNotNull(search);
             assertTrue(search.getGeocodes().contains(mockedCache.getGeocode()));
-
-            parsedCache = cgeoapplication.getInstance().loadCache(mockedCache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB);
+            parsedCache = cgData.loadCache(mockedCache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB);
 
             assertEquals(Settings.isPremiumMember(), mockedCache.getCoords().equals(parsedCache.getCoords()));
             assertEquals(Settings.isPremiumMember(), parsedCache.isReliableLatLon());
@@ -332,7 +330,7 @@ public class cgeoApplicationTest extends CGeoTestCase {
             assertNotNull(search);
             assertTrue(search.getGeocodes().contains(cache.getGeocode()));
             // coords differ
-            cgCache cacheFromViewport = cgeoapplication.getInstance().loadCache(cache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB);
+            cgCache cacheFromViewport = cgData.loadCache(cache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB);
             Log.d("cgeoApplicationTest.testSearchByViewportNotLoggedIn: Coords expected = " + cache.getCoords());
             Log.d("cgeoApplicationTest.testSearchByViewportNotLoggedIn: Coords actual = " + cacheFromViewport.getCoords());
             assertFalse(cache.getCoords().isEqualTo(cacheFromViewport.getCoords(), 1e-3));
@@ -390,7 +388,7 @@ public class cgeoApplicationTest extends CGeoTestCase {
 
     /** Remove cache from DB and cache to ensure that the cache is not loaded from the database */
     private static void deleteCacheFromDB(String geocode) {
-        cgeoapplication.getInstance().removeCache(geocode, LoadFlags.REMOVE_ALL);
+        cgData.removeCache(geocode, LoadFlags.REMOVE_ALL);
     }
 
     /** Remove cache from DB and cache to ensure that the cache is not loaded from the database */
diff --git a/tests/src/cgeo/geocaching/connector/opencaching/OkapiClientTest.java b/tests/src/cgeo/geocaching/connector/opencaching/OkapiClientTest.java
index 5576028..0519b58 100644
--- a/tests/src/cgeo/geocaching/connector/opencaching/OkapiClientTest.java
+++ b/tests/src/cgeo/geocaching/connector/opencaching/OkapiClientTest.java
@@ -2,7 +2,7 @@ package cgeo.geocaching.connector.opencaching;
 
 import cgeo.CGeoTestCase;
 import cgeo.geocaching.cgCache;
-import cgeo.geocaching.cgeoapplication;
+import cgeo.geocaching.cgData;
 import cgeo.geocaching.connector.oc.OkapiClient;
 import cgeo.geocaching.enumerations.LoadFlags;
 
@@ -15,9 +15,8 @@ public class OkapiClientTest extends CGeoTestCase {
         assertEquals(geoCode, cache.getGeocode());
         assertEquals("Oshkosh Municipal Tank", cache.getName());
         assertTrue(cache.isDetailed());
-
         // cache should be stored to DB (to listID 0) when loaded above
-        cache = cgeoapplication.getInstance().loadCache(geoCode, LoadFlags.LOAD_ALL_DB_ONLY);
+        cache = cgData.loadCache(geoCode, LoadFlags.LOAD_ALL_DB_ONLY);
         assertNotNull(cache);
         assertEquals(geoCode, cache.getGeocode());
         assertEquals("Oshkosh Municipal Tank", cache.getName());
diff --git a/tests/src/cgeo/geocaching/files/GPXImporterTest.java b/tests/src/cgeo/geocaching/files/GPXImporterTest.java
index a7f8a68..8c05ee0 100644
--- a/tests/src/cgeo/geocaching/files/GPXImporterTest.java
+++ b/tests/src/cgeo/geocaching/files/GPXImporterTest.java
@@ -3,7 +3,7 @@ package cgeo.geocaching.files;
 import cgeo.geocaching.SearchResult;
 import cgeo.geocaching.Settings;
 import cgeo.geocaching.cgCache;
-import cgeo.geocaching.cgeoapplication;
+import cgeo.geocaching.cgData;
 import cgeo.geocaching.enumerations.CacheType;
 import cgeo.geocaching.enumerations.LoadFlags;
 import cgeo.geocaching.test.AbstractResourceInstrumentationTestCase;
@@ -71,8 +71,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase {
         assertEquals(GPXImporter.IMPORT_STEP_FINISHED, iMsg.next().what);
         SearchResult search = (SearchResult) importStepHandler.messages.get(3).obj;
         assertEquals(Collections.singletonList(geocode), new ArrayList<String>(search.getGeocodes()));
-
-        cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
+        cgCache cache = cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
         assertCacheProperties(cache);
 
         assertTrue(cache.getWaypoints().isEmpty());
@@ -99,8 +98,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase {
         assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_READ_WPT_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED);
         SearchResult search = (SearchResult) importStepHandler.messages.get(4).obj;
         assertEquals(Collections.singletonList("GC31J2H"), new ArrayList<String>(search.getGeocodes()));
-
-        cgCache cache = cgeoapplication.getInstance().loadCache("GC31J2H", LoadFlags.LOAD_CACHE_OR_DB);
+        cgCache cache = cgData.loadCache("GC31J2H", LoadFlags.LOAD_CACHE_OR_DB);
         assertCacheProperties(cache);
         assertEquals(2, cache.getWaypoints().size());
     }
@@ -113,8 +111,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase {
         runImportThread(importThread);
 
         assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED);
-
-        final cgCache cache = cgeoapplication.getInstance().loadCache("AID1", LoadFlags.LOAD_CACHE_OR_DB);
+        final cgCache cache = cgData.loadCache("AID1", LoadFlags.LOAD_CACHE_OR_DB);
         assertCacheProperties(cache);
         assertEquals("First Aid Station #1", cache.getName());
     }
@@ -136,8 +133,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase {
         assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED);
         SearchResult search = (SearchResult) importStepHandler.messages.get(3).obj;
         assertEquals(Collections.singletonList("OC5952"), new ArrayList<String>(search.getGeocodes()));
-
-        cgCache cache = cgeoapplication.getInstance().loadCache("OC5952", LoadFlags.LOAD_CACHE_OR_DB);
+        cgCache cache = cgData.loadCache("OC5952", LoadFlags.LOAD_CACHE_OR_DB);
         assertCacheProperties(cache);
     }
 
@@ -179,8 +175,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase {
         assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED);
         SearchResult search = (SearchResult) importStepHandler.messages.get(3).obj;
         assertEquals(Collections.singletonList(geocode), new ArrayList<String>(search.getGeocodes()));
-
-        cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
+        cgCache cache = cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
         assertCacheProperties(cache);
 
         assertTrue(cache.getWaypoints().isEmpty());
@@ -198,8 +193,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase {
         assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_READ_WPT_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED);
         SearchResult search = (SearchResult) importStepHandler.messages.get(4).obj;
         assertEquals(Collections.singletonList(geocode), new ArrayList<String>(search.getGeocodes()));
-
-        cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
+        cgCache cache = cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
         assertCacheProperties(cache);
         assertEquals(1, cache.getWaypoints().size()); // this is the original pocket query result without test waypoint
     }
@@ -225,8 +219,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase {
         assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_READ_WPT_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED);
         SearchResult search = (SearchResult) importStepHandler.messages.get(4).obj;
         assertEquals(Collections.singletonList(geocode), new ArrayList<String>(search.getGeocodes()));
-
-        cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
+        cgCache cache = cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
         assertCacheProperties(cache);
         assertEquals(1, cache.getWaypoints().size()); // this is the original pocket query result without test waypoint
     }
@@ -266,10 +259,9 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase {
 
         tempDir = new File(System.getProperty("java.io.tmpdir"), "cgeogpxesTest");
         tempDir.mkdir();
-
         // workaround to get storage initialized
-        cgeoapplication.getInstance().getAllHistoricCachesCount();
-        listId = cgeoapplication.getInstance().createList("cgeogpxesTest");
+        cgData.getAllHistoryCachesCount();
+        listId = cgData.createList("cgeogpxesTest");
 
         importCacheStaticMaps = Settings.isStoreOfflineMaps();
         Settings.setStoreOfflineMaps(true);
@@ -279,11 +271,11 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase {
 
     @Override
     protected void tearDown() throws Exception {
-        SearchResult search = cgeoapplication.getInstance().getBatchOfStoredCaches(null, CacheType.ALL, listId);
+        SearchResult search = cgData.getBatchOfStoredCaches(null, CacheType.ALL, listId);
         List<cgCache> cachesInList = new ArrayList<cgCache>();
         cachesInList.addAll(search.getCachesFromSearchResult(LoadFlags.LOAD_CACHE_OR_DB));
-        cgeoapplication.getInstance().markDropped(cachesInList);
-        cgeoapplication.getInstance().removeList(listId);
+        cgData.markDropped(cachesInList);
+        cgData.removeList(listId);
         deleteDirectory(tempDir);
         Settings.setStoreOfflineMaps(importCacheStaticMaps);
         Settings.setStoreOfflineWpMaps(importWpStaticMaps);
diff --git a/tests/src/cgeo/geocaching/files/GPXParserTest.java b/tests/src/cgeo/geocaching/files/GPXParserTest.java
index cd4ac61..f6e6e66 100644
--- a/tests/src/cgeo/geocaching/files/GPXParserTest.java
+++ b/tests/src/cgeo/geocaching/files/GPXParserTest.java
@@ -4,8 +4,8 @@ import cgeo.geocaching.LogEntry;
 import cgeo.geocaching.SearchResult;
 import cgeo.geocaching.StoredList;
 import cgeo.geocaching.cgCache;
+import cgeo.geocaching.cgData;
 import cgeo.geocaching.cgWaypoint;
-import cgeo.geocaching.cgeoapplication;
 import cgeo.geocaching.enumerations.CacheSize;
 import cgeo.geocaching.enumerations.CacheType;
 import cgeo.geocaching.enumerations.LoadFlags;
@@ -213,7 +213,7 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase {
             }
         }
         // reload caches, because the parser only returns the minimum version of each cache
-        return new ArrayList<cgCache>(cgeoapplication.getInstance().loadCaches(result, LoadFlags.LOAD_ALL_DB_ONLY));
+        return new ArrayList<cgCache>(cgData.loadCaches(result, LoadFlags.LOAD_ALL_DB_ONLY));
     }
 
     public static void testParseDateWithFractionalSeconds() {
@@ -266,10 +266,9 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase {
         removeCacheCompletely(geocode);
         final List<cgCache> caches = readGPX10(R.raw.lazy);
         assertEquals(1, caches.size());
-        cgeoapplication.getInstance().removeAllFromCache();
-
+        cgData.removeAllFromCache();
         // load only the minimum cache, it has several members missing
-        final cgCache minimalCache = cgeoapplication.getInstance().loadCache(geocode, EnumSet.of(LoadFlag.LOAD_DB_MINIMAL));
+        final cgCache minimalCache = cgData.loadCache(geocode, EnumSet.of(LoadFlag.LOAD_DB_MINIMAL));
 
         // now check that we load lazy members on demand
         assertFalse(minimalCache.getAttributes().isEmpty());
@@ -298,17 +297,17 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase {
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        listId = cgeoapplication.getInstance().createList("Temporary unit testing");
+        listId = cgData.createList("Temporary unit testing");
         assertTrue(listId != StoredList.TEMPORARY_LIST_ID);
         assertTrue(listId != StoredList.STANDARD_LIST_ID);
     }
 
     @Override
     protected void tearDown() throws Exception {
-        SearchResult search = cgeoapplication.getInstance().getBatchOfStoredCaches(null, CacheType.ALL, listId);
+        SearchResult search = cgData.getBatchOfStoredCaches(null, CacheType.ALL, listId);
         assertNotNull(search);
-        cgeoapplication.getInstance().removeCaches(search.getGeocodes(), LoadFlags.REMOVE_ALL);
-        cgeoapplication.getInstance().removeList(listId);
+        cgData.removeCaches(search.getGeocodes(), LoadFlags.REMOVE_ALL);
+        cgData.removeList(listId);
         super.tearDown();
     }
 }
diff --git a/tests/src/cgeo/geocaching/test/AbstractResourceInstrumentationTestCase.java b/tests/src/cgeo/geocaching/test/AbstractResourceInstrumentationTestCase.java
index 0d3d53b..cd8b5e7 100644
--- a/tests/src/cgeo/geocaching/test/AbstractResourceInstrumentationTestCase.java
+++ b/tests/src/cgeo/geocaching/test/AbstractResourceInstrumentationTestCase.java
@@ -1,6 +1,6 @@
 package cgeo.geocaching.test;
 
-import cgeo.geocaching.cgeoapplication;
+import cgeo.geocaching.cgData;
 import cgeo.geocaching.enumerations.LoadFlags;
 import cgeo.geocaching.enumerations.LoadFlags.RemoveFlag;
 
@@ -18,7 +18,7 @@ public abstract class AbstractResourceInstrumentationTestCase extends Instrument
     protected static void removeCacheCompletely(final String geocode) {
         final EnumSet<RemoveFlag> flags = EnumSet.copyOf(LoadFlags.REMOVE_ALL);
         flags.add(RemoveFlag.REMOVE_OWN_WAYPOINTS_ONLY_FOR_TESTING);
-        cgeoapplication.getInstance().removeCache(geocode, flags);
+        cgData.removeCache(geocode, flags);
     }
 
     protected InputStream getResourceStream(int resourceId) {