diff options
Diffstat (limited to 'tests/src')
64 files changed, 1367 insertions, 542 deletions
diff --git a/tests/src/cgeo/CGeoTestCase.java b/tests/src/cgeo/CGeoTestCase.java index 31fde34..6a63cbc 100644 --- a/tests/src/cgeo/CGeoTestCase.java +++ b/tests/src/cgeo/CGeoTestCase.java @@ -1,6 +1,8 @@ package cgeo; +import cgeo.geocaching.cgData; import cgeo.geocaching.cgeoapplication; +import cgeo.geocaching.enumerations.LoadFlags; import android.test.ApplicationTestCase; @@ -16,4 +18,9 @@ public abstract class CGeoTestCase extends ApplicationTestCase<cgeoapplication> createApplication(); } + /** Remove cache from DB and cache to ensure that the cache is not loaded from the database */ + protected static void deleteCacheFromDB(String geocode) { + cgData.removeCache(geocode, LoadFlags.REMOVE_ALL); + } + } diff --git a/tests/src/cgeo/geocaching/CacheTest.java b/tests/src/cgeo/geocaching/CacheTest.java index e1d6efb..20c7d9e 100644 --- a/tests/src/cgeo/geocaching/CacheTest.java +++ b/tests/src/cgeo/geocaching/CacheTest.java @@ -8,7 +8,7 @@ import java.util.Date; public class CacheTest extends AndroidTestCase { - final static private class MockedEventCache extends cgCache { + final static private class MockedEventCache extends Geocache { public MockedEventCache(final Date date) { setHidden(date); setType(CacheType.EVENT); @@ -17,7 +17,7 @@ public class CacheTest extends AndroidTestCase { public static void testCanBeAddedToCalendar() { final Date today = new Date(); - final cgCache cacheToday = new MockedEventCache(today); + final Geocache cacheToday = new MockedEventCache(today); assertTrue(cacheToday.canBeAddedToCalendar()); final Date yesterday = new Date(today.getTime() - 86400 * 1000); @@ -26,8 +26,8 @@ public class CacheTest extends AndroidTestCase { } public static void testEquality() { - final cgCache one = new cgCache(); - final cgCache two = new cgCache(); + final Geocache one = new Geocache(); + final Geocache two = new Geocache(); // identity assertTrue(one.equals(one)); @@ -41,4 +41,10 @@ public class CacheTest extends AndroidTestCase { // different objects with same geocode shall be equal assertTrue(one.equals(two)); } + + public static void testGeocodeUppercase() { + final Geocache cache = new Geocache(); + cache.setGeocode("gc1234"); + assertEquals("GC1234", cache.getGeocode()); + } } diff --git a/tests/src/cgeo/geocaching/cgeogpxesTest.java b/tests/src/cgeo/geocaching/GpxFileListActivityTest.java index 8f9de4a..a7605d6 100644 --- a/tests/src/cgeo/geocaching/cgeogpxesTest.java +++ b/tests/src/cgeo/geocaching/GpxFileListActivityTest.java @@ -4,11 +4,11 @@ import android.annotation.TargetApi; import android.test.ActivityInstrumentationTestCase2; @TargetApi(8) -public class cgeogpxesTest extends ActivityInstrumentationTestCase2<cgeogpxes> { - private final cgeogpxes importGpxActivity = new cgeogpxes(); +public class GpxFileListActivityTest extends ActivityInstrumentationTestCase2<GpxFileListActivity> { + private final GpxFileListActivity importGpxActivity = new GpxFileListActivity(); - public cgeogpxesTest() { - super(cgeogpxes.class); + public GpxFileListActivityTest() { + super(GpxFileListActivity.class); } public void testFileNameMatches() { diff --git a/tests/src/cgeo/geocaching/SettingsTest.java b/tests/src/cgeo/geocaching/SettingsTest.java index 7713fae..d6b4985 100644 --- a/tests/src/cgeo/geocaching/SettingsTest.java +++ b/tests/src/cgeo/geocaching/SettingsTest.java @@ -13,11 +13,6 @@ public class SettingsTest extends ActivityInstrumentationTestCase2<cgeo> { super(cgeo.class); } - @Override - protected void setUp() throws Exception { - super.setUp(); - } - /** * access settings. * this should work fine without an exception (once there was an exception because of the empty map file string) @@ -30,7 +25,7 @@ public class SettingsTest extends ActivityInstrumentationTestCase2<cgeo> { } public static void testSettings() { - assertEquals(Settings.getMemberStatus(), GCConstants.MEMBER_STATUS_PM); + assertEquals(GCConstants.MEMBER_STATUS_PM, Settings.getMemberStatus()); } public static void testDeviceHasNormalLogin() { diff --git a/tests/src/cgeo/geocaching/StoredListTest.java b/tests/src/cgeo/geocaching/StoredListTest.java new file mode 100644 index 0000000..dd8b6c7 --- /dev/null +++ b/tests/src/cgeo/geocaching/StoredListTest.java @@ -0,0 +1,18 @@ +package cgeo.geocaching; + +import junit.framework.TestCase; + +public class StoredListTest extends TestCase { + + public static void testStandardListExists() { + final StoredList list = cgData.getList(StoredList.STANDARD_LIST_ID); + assertNotNull(list); + } + + public static void testEquals() { + final StoredList list1 = cgData.getList(StoredList.STANDARD_LIST_ID); + final StoredList list2 = cgData.getList(StoredList.STANDARD_LIST_ID); + assertEquals(list1, list2); + } + +} diff --git a/tests/src/cgeo/geocaching/TrackableTest.java b/tests/src/cgeo/geocaching/TrackableTest.java new file mode 100644 index 0000000..2852a4d --- /dev/null +++ b/tests/src/cgeo/geocaching/TrackableTest.java @@ -0,0 +1,18 @@ +package cgeo.geocaching; + +import android.test.AndroidTestCase; + +public class TrackableTest extends AndroidTestCase { + + public static void testGetGeocode() { + final Trackable trackable = new Trackable(); + trackable.setGeocode("tb1234"); + assertEquals("TB1234", trackable.getGeocode()); + } + + public static void testSetLogsNull() { + final Trackable trackable = new Trackable(); + trackable.setLogs(null); + assertNotNull("Trackable logs must not be null!", trackable.getLogs()); + } +} diff --git a/tests/src/cgeo/geocaching/cgWaypointTest.java b/tests/src/cgeo/geocaching/WaypointTest.java index 324d562..974fca3 100644 --- a/tests/src/cgeo/geocaching/cgWaypointTest.java +++ b/tests/src/cgeo/geocaching/WaypointTest.java @@ -4,15 +4,15 @@ import cgeo.geocaching.enumerations.WaypointType; import android.test.AndroidTestCase; -public class cgWaypointTest extends AndroidTestCase { +public class WaypointTest extends AndroidTestCase { public static void testOrder() { - final cgWaypoint cache = new cgWaypoint("Final", WaypointType.FINAL, false); - final cgWaypoint trailhead = new cgWaypoint("Trail head", WaypointType.TRAILHEAD, false); - final cgWaypoint stage = new cgWaypoint("stage", WaypointType.STAGE, false); - final cgWaypoint puzzle = new cgWaypoint("puzzle", WaypointType.PUZZLE, false); - final cgWaypoint own = new cgWaypoint("own", WaypointType.OWN, true); - final cgWaypoint parking = new cgWaypoint("parking", WaypointType.PARKING, false); + final Waypoint cache = new Waypoint("Final", WaypointType.FINAL, false); + final Waypoint trailhead = new Waypoint("Trail head", WaypointType.TRAILHEAD, false); + final Waypoint stage = new Waypoint("stage", WaypointType.STAGE, false); + final Waypoint puzzle = new Waypoint("puzzle", WaypointType.PUZZLE, false); + final Waypoint own = new Waypoint("own", WaypointType.OWN, true); + final Waypoint parking = new Waypoint("parking", WaypointType.PARKING, false); assertTrue(trailhead.compareTo(puzzle) < 0); assertTrue(trailhead.compareTo(stage) < 0); @@ -33,4 +33,9 @@ public class cgWaypointTest extends AndroidTestCase { assertTrue(parking.compareTo(trailhead) < 0); } + public static void testGeocode() { + final Waypoint waypoint = new Waypoint("Test waypoint", WaypointType.PARKING, false); + waypoint.setGeocode("p1"); + assertEquals("P1", waypoint.getGeocode()); + } } diff --git a/tests/src/cgeo/geocaching/cgDataTest.java b/tests/src/cgeo/geocaching/cgDataTest.java index 3cee32f..a6fb846 100644 --- a/tests/src/cgeo/geocaching/cgDataTest.java +++ b/tests/src/cgeo/geocaching/cgDataTest.java @@ -18,25 +18,24 @@ 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; // create caches - final cgCache cache1 = new cgCache(); + final Geocache cache1 = new Geocache(); cache1.setGeocode("Cache 1"); - final cgCache cache2 = new cgCache(); + final Geocache cache2 = new Geocache(); cache2.setGeocode("Cache 2"); assertNotNull(cache2); 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,95 +43,90 @@ 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(app.getAllStoredCachesCount(false, CacheType.ALL) >= 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); + final 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(false, 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(false, 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 { // remove caches - Set<String> geocodes = new HashSet<String>(); + final 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 - final cgCache cache = new cgCache(); + final Geocache cache = new Geocache(); cache.setGeocode(GEOCODE_CACHE); cache.setDetailed(true); - final cgTrackable trackable = new cgTrackable(); + final Trackable trackable = new Trackable(); trackable.setLogs(null); - final List<cgTrackable> inventory = new ArrayList<cgTrackable>(); + final List<Trackable> inventory = new ArrayList<Trackable>(); inventory.add(trackable); 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 Geocache 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(""); + final 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..9c882a5 100644 --- a/tests/src/cgeo/geocaching/cgeoApplicationTest.java +++ b/tests/src/cgeo/geocaching/cgeoApplicationTest.java @@ -56,7 +56,7 @@ public class cgeoApplicationTest extends CGeoTestCase { */ @MediumTest public static void testSearchTrackableNotExisting() { - cgTrackable tb = GCParser.searchTrackable("123456", null, null); + final Trackable tb = GCParser.searchTrackable("123456", null, null); assertNull(tb); } @@ -65,7 +65,7 @@ public class cgeoApplicationTest extends CGeoTestCase { */ @MediumTest public static void testSearchTrackable() { - final cgTrackable tb = GCParser.searchTrackable("TB2J1VZ", null, null); + final Trackable tb = GCParser.searchTrackable("TB2J1VZ", null, null); // fix data assertEquals("aefffb86-099f-444f-b132-605436163aa8", tb.getGuid()); assertEquals("TB2J1VZ", tb.getGeocode()); @@ -82,7 +82,7 @@ public class cgeoApplicationTest extends CGeoTestCase { // Following data can change over time assertTrue(tb.getDistance() >= 10617.8f); assertTrue(tb.getLogs().size() >= 10); - assertTrue(cgTrackable.SPOTTED_CACHE == tb.getSpottedType() || cgTrackable.SPOTTED_USER == tb.getSpottedType()); + assertTrue(Trackable.SPOTTED_CACHE == tb.getSpottedType() || Trackable.SPOTTED_USER == tb.getSpottedType()); // no assumption possible: assertEquals("faa2d47d-19ea-422f-bec8-318fc82c8063", tb.getSpottedGuid()); // no assumption possible: assertEquals("Nice place for a break cache", tb.getSpottedName()); @@ -103,13 +103,13 @@ public class cgeoApplicationTest extends CGeoTestCase { * Test {@link cgBase#searchByGeocode(String, String, int, boolean, CancellableHandler)} */ @MediumTest - public static cgCache testSearchByGeocode(final String geocode) { - final SearchResult search = cgCache.searchByGeocode(geocode, null, 0, true, null); + public static Geocache testSearchByGeocode(final String geocode) { + final SearchResult search = Geocache.searchByGeocode(geocode, null, 0, true, null); assertNotNull(search); 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; @@ -120,7 +120,7 @@ public class cgeoApplicationTest extends CGeoTestCase { */ @MediumTest public static void testSearchByGeocodeNotExisting() { - final SearchResult search = cgCache.searchByGeocode("GC123456", null, 0, true, null); + final SearchResult search = Geocache.searchByGeocode("GC123456", null, 0, true, null); assertNotNull(search); assertEquals(StatusCode.UNPUBLISHED_CACHE, search.getError()); } @@ -130,8 +130,8 @@ public class cgeoApplicationTest extends CGeoTestCase { */ @MediumTest public static void testSearchByGeocodeNotLoggedIn() { - ImmutablePair<String, String> login = Settings.getLogin(); - String memberStatus = Settings.getMemberStatus(); + final ImmutablePair<String, String> login = Settings.getLogin(); + final String memberStatus = Settings.getMemberStatus(); try { // non premium cache @@ -139,11 +139,11 @@ public class cgeoApplicationTest extends CGeoTestCase { deleteCacheFromDBAndLogout(cache.getGeocode()); - SearchResult search = cgCache.searchByGeocode(cache.getGeocode(), null, StoredList.TEMPORARY_LIST_ID, true, null); + SearchResult search = Geocache.searchByGeocode(cache.getGeocode(), null, StoredList.TEMPORARY_LIST_ID, true, null); assertNotNull(search); assertEquals(1, search.getGeocodes().size()); assertTrue(search.getGeocodes().contains(cache.getGeocode())); - cgCache searchedCache = search.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB); + final Geocache searchedCache = search.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB); // coords must be null if the user is not logged in assertNull(searchedCache.getCoords()); @@ -152,7 +152,7 @@ public class cgeoApplicationTest extends CGeoTestCase { deleteCacheFromDBAndLogout(cache.getGeocode()); - search = cgCache.searchByGeocode(cache.getGeocode(), null, StoredList.TEMPORARY_LIST_ID, true, null); + search = Geocache.searchByGeocode(cache.getGeocode(), null, StoredList.TEMPORARY_LIST_ID, true, null); assertNotNull(search); assertEquals(0, search.getGeocodes().size()); @@ -169,16 +169,16 @@ public class cgeoApplicationTest extends CGeoTestCase { */ @MediumTest public static void testSearchErrorOccured() { - ImmutablePair<String, String> login = Settings.getLogin(); - String memberStatus = Settings.getMemberStatus(); + final ImmutablePair<String, String> login = Settings.getLogin(); + final String memberStatus = Settings.getMemberStatus(); try { // non premium cache - MockedCache cache = new GC1ZXX2(); + final MockedCache cache = new GC1ZXX2(); deleteCacheFromDBAndLogout(cache.getGeocode()); - SearchResult search = cgCache.searchByGeocode(cache.getGeocode(), null, StoredList.TEMPORARY_LIST_ID, true, null); + final SearchResult search = Geocache.searchByGeocode(cache.getGeocode(), null, StoredList.TEMPORARY_LIST_ID, true, null); assertNotNull(search); assertEquals(0, search.getGeocodes().size()); @@ -191,46 +191,60 @@ public class cgeoApplicationTest extends CGeoTestCase { } /** - * Test {@link cgBase#searchByCoords(AbstractSearchThread, Geopoint, String, int, boolean)} + * mock the "exclude disabled caches" and "exclude my caches" options for the execution of the runnable + * + * @param runnable */ - @MediumTest - public static void testSearchByCoords() { + private static void withMockedFilters(Runnable runnable) { // backup user settings final boolean excludeMine = Settings.isExcludeMyCaches(); + final boolean excludeDisabled = Settings.isExcludeDisabledCaches(); try { // set up settings required for test Settings.setExcludeMine(false); + Settings.setExcludeDisabledCaches(false); + + runnable.run(); - final SearchResult search = GCParser.searchByCoords(new Geopoint("N 52° 24.972 E 009° 35.647"), CacheType.MYSTERY, false); - assertNotNull(search); - assertTrue(20 <= search.getGeocodes().size()); - assertTrue(search.getGeocodes().contains("GC1RMM2")); } finally { // restore user settings Settings.setExcludeMine(excludeMine); + Settings.setExcludeDisabledCaches(excludeDisabled); } } /** + * Test {@link cgBase#searchByCoords(AbstractSearchThread, Geopoint, String, int, boolean)} + */ + @MediumTest + public static void testSearchByCoords() { + withMockedFilters(new Runnable() { + + @Override + public void run() { + final SearchResult search = GCParser.searchByCoords(new Geopoint("N 52° 24.972 E 009° 35.647"), CacheType.MYSTERY, false); + assertNotNull(search); + assertTrue(20 <= search.getGeocodes().size()); + assertTrue(search.getGeocodes().contains("GC1RMM2")); + } + }); + } + + /** * Test {@link cgBase#searchByOwner(String, String, int, boolean, CancellableHandler)} */ @MediumTest public static void testSearchByOwner() { - // backup user settings - final boolean excludeMine = Settings.isExcludeMyCaches(); - try { - // set up settings required for test - Settings.setExcludeMine(false); - - final SearchResult search = GCParser.searchByOwner("blafoo", CacheType.MYSTERY, false); - assertNotNull(search); - assertEquals(3, search.getGeocodes().size()); - assertTrue(search.getGeocodes().contains("GC36RT6")); - - } finally { - // restore user settings - Settings.setExcludeMine(excludeMine); - } + withMockedFilters(new Runnable() { + + @Override + public void run() { + final SearchResult search = GCParser.searchByOwner("blafoo", CacheType.MYSTERY, false); + assertNotNull(search); + assertEquals(3, search.getGeocodes().size()); + assertTrue(search.getGeocodes().contains("GC36RT6")); + } + }); } /** @@ -238,21 +252,16 @@ public class cgeoApplicationTest extends CGeoTestCase { */ @MediumTest public static void testSearchByUsername() { - // backup user settings - final boolean excludeMine = Settings.isExcludeMyCaches(); - try { - // set up settings required for test - Settings.setExcludeMine(false); - - final SearchResult search = GCParser.searchByUsername("blafoo", CacheType.WEBCAM, false); - assertNotNull(search); - assertEquals(3, search.getTotal()); - assertTrue(search.getGeocodes().contains("GCP0A9")); - - } finally { - // restore user settings - Settings.setExcludeMine(excludeMine); - } + withMockedFilters(new Runnable() { + + @Override + public void run() { + final SearchResult search = GCParser.searchByUsername("blafoo", CacheType.WEBCAM, false); + assertNotNull(search); + assertEquals(3, search.getTotal()); + assertTrue(search.getGeocodes().contains("GCP0A9")); + } + }); } /** @@ -260,49 +269,54 @@ public class cgeoApplicationTest extends CGeoTestCase { */ @MediumTest public static void testSearchByViewport() { - // backup user settings - final boolean excludeMine = Settings.isExcludeMyCaches(); - final Strategy strategy = Settings.getLiveMapStrategy(); - - try { - // set up settings required for test - Settings.setExcludeMine(false); - - final GC2CJPF mockedCache = new GC2CJPF(); - deleteCacheFromDB(mockedCache.getGeocode()); - - final String[] tokens = Login.getMapTokens(); - final Viewport viewport = new Viewport(mockedCache, 0.003, 0.003); - - // check coords for DETAILED - Settings.setLiveMapStrategy(Strategy.DETAILED); - 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); - - assertEquals(Settings.isPremiumMember(), mockedCache.getCoords().equals(parsedCache.getCoords())); - assertEquals(Settings.isPremiumMember(), parsedCache.isReliableLatLon()); - - // check update after switch strategy to FAST - Settings.setLiveMapStrategy(Strategy.FAST); - Tile.Cache.removeFromTileCache(mockedCache); - - search = ConnectorFactory.searchByViewport(viewport, tokens); - assertNotNull(search); - assertTrue(search.getGeocodes().contains(mockedCache.getGeocode())); - - parsedCache = cgeoapplication.getInstance().loadCache(mockedCache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB); - - assertEquals(Settings.isPremiumMember(), mockedCache.getCoords().equals(parsedCache.getCoords())); - assertEquals(Settings.isPremiumMember(), parsedCache.isReliableLatLon()); - - } finally { - // restore user settings - Settings.setExcludeMine(excludeMine); - Settings.setLiveMapStrategy(strategy); - } + withMockedFilters(new Runnable() { + + @Override + public void run() { + // backup user settings + final Strategy strategy = Settings.getLiveMapStrategy(); + final CacheType cacheType = Settings.getCacheType(); + + try { + // set up settings required for test + Settings.setExcludeMine(false); + Settings.setCacheType(CacheType.ALL); + + final GC2CJPF mockedCache = new GC2CJPF(); + deleteCacheFromDB(mockedCache.getGeocode()); + + final String[] tokens = Login.getMapTokens(); + final Viewport viewport = new Viewport(mockedCache, 0.003, 0.003); + + // check coords for DETAILED + Settings.setLiveMapStrategy(Strategy.DETAILED); + SearchResult search = ConnectorFactory.searchByViewport(viewport, tokens); + assertNotNull(search); + assertTrue(search.getGeocodes().contains(mockedCache.getGeocode())); + Geocache parsedCache = cgData.loadCache(mockedCache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB); + + assertEquals(Settings.isPremiumMember(), mockedCache.getCoords().equals(parsedCache.getCoords())); + assertEquals(Settings.isPremiumMember(), parsedCache.isReliableLatLon()); + + // check update after switch strategy to FAST + Settings.setLiveMapStrategy(Strategy.FAST); + Tile.Cache.removeFromTileCache(mockedCache); + + search = ConnectorFactory.searchByViewport(viewport, tokens); + assertNotNull(search); + assertTrue(search.getGeocodes().contains(mockedCache.getGeocode())); + parsedCache = cgData.loadCache(mockedCache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB); + + assertEquals(Settings.isPremiumMember(), mockedCache.getCoords().equals(parsedCache.getCoords())); + assertEquals(Settings.isPremiumMember(), parsedCache.isReliableLatLon()); + + } finally { + // restore user settings + Settings.setLiveMapStrategy(strategy); + Settings.setCacheType(cacheType); + } + } + }); } /** @@ -311,11 +325,12 @@ public class cgeoApplicationTest extends CGeoTestCase { @MediumTest public static void testSearchByViewportNotLoggedIn() { - ImmutablePair<String, String> login = Settings.getLogin(); - String memberStatus = Settings.getMemberStatus(); - Strategy strategy = Settings.getLiveMapStrategy(); - Strategy testStrategy = Strategy.FAST; // FASTEST, FAST or DETAILED for tests + final ImmutablePair<String, String> login = Settings.getLogin(); + final String memberStatus = Settings.getMemberStatus(); + final Strategy strategy = Settings.getLiveMapStrategy(); + final Strategy testStrategy = Strategy.FAST; // FASTEST, FAST or DETAILED for tests Settings.setLiveMapStrategy(testStrategy); + final CacheType cacheType = Settings.getCacheType(); try { @@ -325,6 +340,7 @@ public class cgeoApplicationTest extends CGeoTestCase { MockedCache cache = new GC2CJPF(); deleteCacheFromDBAndLogout(cache.getGeocode()); Tile.Cache.removeFromTileCache(cache); + Settings.setCacheType(CacheType.ALL); Viewport viewport = new Viewport(cache, 0.003, 0.003); SearchResult search = ConnectorFactory.searchByViewport(viewport, tokens); @@ -332,7 +348,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); + final Geocache 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)); @@ -356,6 +372,7 @@ public class cgeoApplicationTest extends CGeoTestCase { Settings.setMemberStatus(memberStatus); Login.login(); Settings.setLiveMapStrategy(strategy); + Settings.setCacheType(cacheType); } } @@ -367,7 +384,7 @@ public class cgeoApplicationTest extends CGeoTestCase { String oldUser = mockedCache.getMockedDataUser(); try { mockedCache.setMockedDataUser(Settings.getUsername()); - cgCache parsedCache = cgeoApplicationTest.testSearchByGeocode(mockedCache.getGeocode()); + Geocache parsedCache = cgeoApplicationTest.testSearchByGeocode(mockedCache.getGeocode()); if (null != parsedCache) { Compare.assertCompareCaches(mockedCache, parsedCache, true); } @@ -381,19 +398,14 @@ public class cgeoApplicationTest extends CGeoTestCase { * Caches that are good test cases */ public static void testSearchByGeocodeSpecialties() { - cgCache GCV2R9 = cgeoApplicationTest.testSearchByGeocode("GCV2R9"); + final Geocache GCV2R9 = cgeoApplicationTest.testSearchByGeocode("GCV2R9"); Assert.assertEquals("California, United States", GCV2R9.getLocation()); - cgCache GC1ZXEZ = cgeoApplicationTest.testSearchByGeocode("GC1ZXEZ"); + final Geocache GC1ZXEZ = cgeoApplicationTest.testSearchByGeocode("GC1ZXEZ"); Assert.assertEquals("Ms.Marple/Mr.Stringer", GC1ZXEZ.getOwnerUserId()); } /** 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); - } - - /** Remove cache from DB and cache to ensure that the cache is not loaded from the database */ private static void deleteCacheFromDBAndLogout(String geocode) { deleteCacheFromDB(geocode); diff --git a/tests/src/cgeo/geocaching/compatibility/CompatibilityTest.java b/tests/src/cgeo/geocaching/compatibility/CompatibilityTest.java index 03034f8..35baa8c 100644 --- a/tests/src/cgeo/geocaching/compatibility/CompatibilityTest.java +++ b/tests/src/cgeo/geocaching/compatibility/CompatibilityTest.java @@ -11,7 +11,7 @@ public class CompatibilityTest extends ActivityInstrumentationTestCase2<cgeo> { private cgeo activity; public CompatibilityTest() { - super(cgeo.class); + super("cgeo.geocaching", cgeo.class); } @Override diff --git a/tests/src/cgeo/geocaching/connector/ConnectorFactoryTest.java b/tests/src/cgeo/geocaching/connector/ConnectorFactoryTest.java index e8abb91..ca396e1 100644 --- a/tests/src/cgeo/geocaching/connector/ConnectorFactoryTest.java +++ b/tests/src/cgeo/geocaching/connector/ConnectorFactoryTest.java @@ -31,7 +31,7 @@ public class ConnectorFactoryTest extends AbstractResourceInstrumentationTestCas assertTrue(ConnectorFactory.getConnector("OP12345") instanceof OCConnector); // opencaching PL } - public static void testGeocodeInvalidFormat() throws Exception { + public static void testGeocodeInvalidFormat() { // all codes are invalid assertTrue(ConnectorFactory.getConnector("GC") instanceof UnknownConnector); assertTrue(ConnectorFactory.getConnector("OC") instanceof UnknownConnector); diff --git a/tests/src/cgeo/geocaching/connector/gc/AutoZoomTest.java b/tests/src/cgeo/geocaching/connector/gc/AutoZoomTest.java index 234ff26..708e328 100644 --- a/tests/src/cgeo/geocaching/connector/gc/AutoZoomTest.java +++ b/tests/src/cgeo/geocaching/connector/gc/AutoZoomTest.java @@ -1,25 +1,70 @@ package cgeo.geocaching.connector.gc; import cgeo.geocaching.geopoint.Geopoint; +import cgeo.geocaching.geopoint.Viewport; + +import java.util.Set; import junit.framework.TestCase; public class AutoZoomTest extends TestCase { public static void testZoom1() { - Geopoint bottomLeft = new Geopoint(49.3, 8.3); - Geopoint topRight = new Geopoint(49.4, 8.4); + final Geopoint bottomLeft = new Geopoint(49.3, 8.3); + final Geopoint topRight = new Geopoint(49.4, 8.4); - int zoom = Tile.calcZoomLat(bottomLeft, topRight); + int zoom = Tile.calcZoomLat(bottomLeft, topRight, 2); assertTrue(Math.abs(new Tile(bottomLeft, zoom).getY() - new Tile(topRight, zoom).getY()) == 1); assertTrue(Math.abs(new Tile(bottomLeft, zoom + 1).getY() - new Tile(topRight, zoom + 1).getY()) > 1); - zoom = Tile.calcZoomLon(bottomLeft, topRight); + zoom = Tile.calcZoomLon(bottomLeft, topRight, 2); assertTrue(new Tile(bottomLeft, zoom).getX() + 1 == new Tile(topRight, zoom).getX()); assertTrue(new Tile(bottomLeft, zoom + 1).getX() + 1 < new Tile(topRight, zoom + 1).getX()); } + public static void testZoom2() { + final Geopoint bottomLeft = new Geopoint(49.3, 8.3); + final Geopoint topRight = new Geopoint(49.4, 8.4); + + int zoom = Tile.calcZoomLat(bottomLeft, topRight, 3); + + assertTrue(Math.abs(new Tile(bottomLeft, zoom).getY() - new Tile(topRight, zoom).getY()) >= 2); + assertTrue(Math.abs(new Tile(bottomLeft, zoom + 1).getY() - new Tile(topRight, zoom + 1).getY()) > 2); + + zoom = Tile.calcZoomLon(bottomLeft, topRight, 3); + + assertTrue(Math.abs(new Tile(bottomLeft, zoom).getX() - new Tile(topRight, zoom).getX()) >= 2); + assertTrue(Math.abs(new Tile(bottomLeft, zoom + 1).getX() - new Tile(topRight, zoom + 1).getX()) > 2); + + } + + public static void testTiles1x2() { + final Geopoint bottomLeft = new Geopoint(49.3, 8.3); + final Geopoint topRight = new Geopoint(49.4, 8.4); + + final Set<Tile> tiles = Tile.getTilesForViewport(new Viewport(bottomLeft, topRight)); + + assertEquals(2, tiles.size()); + } + + public static void testTiles2x3() { + final Geopoint bottomLeft = new Geopoint(49.3, 8.3); + final Geopoint topRight = new Geopoint(49.4, 8.4); + + final Set<Tile> tiles = Tile.getTilesForViewport(new Viewport(bottomLeft, topRight), 3, Tile.ZOOMLEVEL_MIN); + + assertEquals(6, tiles.size()); + } + + public static void testTilesZoom13() { + final Geopoint bottomLeft = new Geopoint(49.3, 8.3); + final Geopoint topRight = new Geopoint(49.4, 8.4); + + final Set<Tile> tiles = Tile.getTilesForViewport(new Viewport(bottomLeft, topRight), 3, 13); + + assertEquals(16, tiles.size()); + } } diff --git a/tests/src/cgeo/geocaching/connector/gc/GCBaseTest.java b/tests/src/cgeo/geocaching/connector/gc/GCBaseTest.java index 91ff2f9..d70ab9b 100644 --- a/tests/src/cgeo/geocaching/connector/gc/GCBaseTest.java +++ b/tests/src/cgeo/geocaching/connector/gc/GCBaseTest.java @@ -1,7 +1,7 @@ package cgeo.geocaching.connector.gc; +import cgeo.geocaching.Geocache; import cgeo.geocaching.SearchResult; -import cgeo.geocaching.cgCache; import cgeo.geocaching.enumerations.LoadFlags; import cgeo.geocaching.test.mock.GC2CJPF; import cgeo.geocaching.test.mock.MockedCache; @@ -34,7 +34,7 @@ public class GCBaseTest extends TestCase { geocodes.add(mockedCache.getGeocode()); final SearchResult result = GCMap.searchByGeocodes(geocodes); - final cgCache parsedCache = result.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_ONLY); + final Geocache parsedCache = result.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_ONLY); Compare.assertCompareCaches(mockedCache, parsedCache, false); diff --git a/tests/src/cgeo/geocaching/connector/gc/GCConnectorTest.java b/tests/src/cgeo/geocaching/connector/gc/GCConnectorTest.java index ea46bbe..a001f1d 100644 --- a/tests/src/cgeo/geocaching/connector/gc/GCConnectorTest.java +++ b/tests/src/cgeo/geocaching/connector/gc/GCConnectorTest.java @@ -3,6 +3,7 @@ package cgeo.geocaching.connector.gc; import cgeo.geocaching.SearchResult; import cgeo.geocaching.Settings; import cgeo.geocaching.connector.ConnectorFactory; +import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.geopoint.Geopoint; import cgeo.geocaching.geopoint.Viewport; import cgeo.geocaching.test.AbstractResourceInstrumentationTestCase; @@ -12,16 +13,18 @@ public class GCConnectorTest extends AbstractResourceInstrumentationTestCase { public static void testGetViewport() { // backup user settings final boolean excludeMine = Settings.isExcludeMyCaches(); + final CacheType cacheType = Settings.getCacheType(); try { // set up settings required for test Settings.setExcludeMine(false); + Settings.setCacheType(CacheType.ALL); Login.login(); - String[] tokens = Login.getMapTokens(); + final String[] tokens = Login.getMapTokens(); { final Viewport viewport = new Viewport(new Geopoint("N 52° 25.369 E 9° 35.499"), new Geopoint("N 52° 25.600 E 9° 36.200")); - SearchResult searchResult = ConnectorFactory.searchByViewport(viewport, tokens); + final SearchResult searchResult = ConnectorFactory.searchByViewport(viewport, tokens); assertNotNull(searchResult); assertFalse(searchResult.isEmpty()); assertTrue(searchResult.getGeocodes().contains("GC211WG")); @@ -30,13 +33,14 @@ public class GCConnectorTest extends AbstractResourceInstrumentationTestCase { { final Viewport viewport = new Viewport(new Geopoint("N 52° 24.000 E 9° 34.500"), new Geopoint("N 52° 26.000 E 9° 38.500")); - SearchResult searchResult = ConnectorFactory.searchByViewport(viewport, tokens); + final SearchResult searchResult = ConnectorFactory.searchByViewport(viewport, tokens); assertNotNull(searchResult); assertTrue(searchResult.getGeocodes().contains("GC211WG")); } } finally { // restore user settings Settings.setExcludeMine(excludeMine); + Settings.setCacheType(cacheType); } } diff --git a/tests/src/cgeo/geocaching/connector/gc/GCConstantsTest.java b/tests/src/cgeo/geocaching/connector/gc/GCConstantsTest.java index 980fcaa..15ad7a3 100644 --- a/tests/src/cgeo/geocaching/connector/gc/GCConstantsTest.java +++ b/tests/src/cgeo/geocaching/connector/gc/GCConstantsTest.java @@ -48,13 +48,13 @@ public class GCConstantsTest extends AndroidTestCase { } public static void testConstants() { - String session = "userSession = new Groundspeak.Map.UserSession('aKWZ', userOptions:'XPTf', sessionToken:'123pNKwdktYGZL0xd-I7yqA6nm_JE1BDUtM4KcOkifin2TRCMutBd_PZE14Ohpffs2ZgkTnxTSnxYpBigK4hBA2', subscriberType: 3, enablePersonalization: true });"; + final String session = "userSession = new Groundspeak.Map.UserSession('aKWZ', userOptions:'XPTf', sessionToken:'123pNKwdktYGZL0xd-I7yqA6nm_JE1BDUtM4KcOkifin2TRCMutBd_PZE14Ohpffs2ZgkTnxTSnxYpBigK4hBA2', subscriberType: 3, enablePersonalization: true });"; assertEquals("aKWZ", BaseUtils.getMatch(session, GCConstants.PATTERN_USERSESSION, "")); assertTrue(BaseUtils.getMatch(session, GCConstants.PATTERN_SESSIONTOKEN, "").startsWith("123pNK")); } public static void testTBWithSpecialChar() { - String page = "<meta name=\"og:site_name\" content=\"Geocaching.com\" property=\"og:site_name\" /><meta name=\"og:type\" content=\"article\" property=\"og:type\" /><meta name=\"fb:app_id\" content=\"100167303362705\" property=\"fb:app_id\" /><meta name=\"og:url\" content=\"http://coord.info/TB4VPZD\" property=\"og:url\" /><meta name=\"og:description\" property=\"og:description\" /><meta name=\"og:image\" content=\"http://www.geocaching.com/images/facebook/wpttypes/24.png\" property=\"og:image\" /><meta name=\"og:title\" content=\"Schlauchen&ravestorm\" property=\"og:title\" /></head>\n"; + final String page = "<meta name=\"og:site_name\" content=\"Geocaching.com\" property=\"og:site_name\" /><meta name=\"og:type\" content=\"article\" property=\"og:type\" /><meta name=\"fb:app_id\" content=\"100167303362705\" property=\"fb:app_id\" /><meta name=\"og:url\" content=\"http://coord.info/TB4VPZD\" property=\"og:url\" /><meta name=\"og:description\" property=\"og:description\" /><meta name=\"og:image\" content=\"http://www.geocaching.com/images/facebook/wpttypes/24.png\" property=\"og:image\" /><meta name=\"og:title\" content=\"Schlauchen&ravestorm\" property=\"og:title\" /></head>\n"; assertEquals("Schlauchen&ravestorm", Html.fromHtml(BaseUtils.getMatch(page, GCConstants.PATTERN_TRACKABLE_NAME, "")).toString()); } } diff --git a/tests/src/cgeo/geocaching/connector/gc/GCParserTest.java b/tests/src/cgeo/geocaching/connector/gc/GCParserTest.java index c8cb8fb..cf1df46 100644 --- a/tests/src/cgeo/geocaching/connector/gc/GCParserTest.java +++ b/tests/src/cgeo/geocaching/connector/gc/GCParserTest.java @@ -1,10 +1,10 @@ package cgeo.geocaching.connector.gc; +import cgeo.geocaching.Geocache; +import cgeo.geocaching.Image; import cgeo.geocaching.SearchResult; import cgeo.geocaching.Settings; -import cgeo.geocaching.cgCache; -import cgeo.geocaching.cgImage; -import cgeo.geocaching.cgWaypoint; +import cgeo.geocaching.Waypoint; import cgeo.geocaching.enumerations.LoadFlags; import cgeo.geocaching.enumerations.StatusCode; import cgeo.geocaching.geopoint.Geopoint; @@ -18,36 +18,65 @@ import cgeo.test.Compare; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.StringUtils; +import android.os.Handler; import android.test.suitebuilder.annotation.MediumTest; import java.util.ArrayList; public class GCParserTest extends AbstractResourceInstrumentationTestCase { - public void testUnpublishedCache() { - final String page = getFileContent(R.raw.cache_unpublished); - SearchResult result = GCParser.parseCacheFromText(page, null); + + public void testUnpublishedCacheNotOwner() { + final int cache = R.raw.cache_unpublished; + assertUnpublished(cache); + } + + public void testUnpublishedCacheOwner() { + final int cache = R.raw.gc433yc_owner_unpublished; + assertUnpublished(cache); + } + + private void assertUnpublished(final int cache) { + final String page = getFileContent(cache); + final SearchResult result = GCParser.parseCacheFromText(page, null); assertNotNull(result); assertTrue(result.isEmpty()); assertEquals(StatusCode.UNPUBLISHED_CACHE, result.getError()); } + public void testPublishedCacheWithUnpublishedInDescription1() { + assertPublishedCache(R.raw.gc430fm_published, "Cache is Unpublished"); + } + + public void testPublishedCacheWithUnpublishedInDescription2() { + assertPublishedCache(R.raw.gc431f2_published, "Needle in a Haystack"); + } + + private void assertPublishedCache(final int cachePage, final String cacheName) { + final String page = getFileContent(cachePage); + final SearchResult result = GCParser.parseCacheFromText(page, null); + assertNotNull(result); + assertEquals(1, result.getCount()); + final Geocache cache = result.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB); + assertEquals(cacheName, cache.getName()); + } + public void testOwnCache() { - final cgCache cache = parseCache(R.raw.own_cache); + final Geocache cache = parseCache(R.raw.own_cache); assertNotNull(cache); assertTrue(CollectionUtils.isNotEmpty(cache.getSpoilers())); assertEquals(1, cache.getSpoilers().size()); - final cgImage spoiler = cache.getSpoilers().get(0); + final Image spoiler = cache.getSpoilers().get(0); assertEquals("http://img.geocaching.com/cache/large/3f9365c3-f55c-4e55-9992-ee0e5175712c.jpg", spoiler.getUrl()); assertEquals("SPOILER", spoiler.getTitle()); assertNull(spoiler.getDescription()); } - private static cgCache createCache(int index) { - final MockedCache mockedCache = RegExPerformanceTest.MOCKED_CACHES[index]; + private static Geocache createCache(int index) { + final MockedCache mockedCache = RegExPerformanceTest.MOCKED_CACHES.get(index); // to get the same results we have to use the date format used when the mocked data was created - String oldCustomDate = Settings.getGcCustomDate(); + final String oldCustomDate = Settings.getGcCustomDate(); - SearchResult searchResult; + final SearchResult searchResult; try { Settings.setGcCustomDate(MockedCache.getDateFormat()); searchResult = GCParser.parseCacheFromText(mockedCache.getData(), null); @@ -58,7 +87,7 @@ public class GCParserTest extends AbstractResourceInstrumentationTestCase { assertNotNull(searchResult); assertEquals(1, searchResult.getCount()); - final cgCache cache = searchResult.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB); + final Geocache cache = searchResult.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB); assertNotNull(cache); return cache; } @@ -69,13 +98,13 @@ public class GCParserTest extends AbstractResourceInstrumentationTestCase { */ @MediumTest public static void testParseCacheFromTextWithMockedData() { - String gcCustomDate = Settings.getGcCustomDate(); + final String gcCustomDate = Settings.getGcCustomDate(); try { for (MockedCache mockedCache : RegExPerformanceTest.MOCKED_CACHES) { // to get the same results we have to use the date format used when the mocked data was created Settings.setGcCustomDate(MockedCache.getDateFormat()); SearchResult searchResult = GCParser.parseCacheFromText(mockedCache.getData(), null); - cgCache parsedCache = searchResult.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB); + Geocache parsedCache = searchResult.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB); assertTrue(StringUtils.isNotBlank(mockedCache.getMockedDataUser())); Compare.assertCompareCaches(mockedCache, parsedCache, true); } @@ -85,7 +114,7 @@ public class GCParserTest extends AbstractResourceInstrumentationTestCase { } public static void testWaypointsFromNote() { - final cgCache cache = createCache(0); + final Geocache cache = createCache(0); final Geopoint[] empty = new Geopoint[] {}; final Geopoint[] one = new Geopoint[] { new Geopoint("N51 21.523", "E7 2.680") }; @@ -121,9 +150,28 @@ public class GCParserTest extends AbstractResourceInstrumentationTestCase { "Station3: N51 21.444 / E07 02.600\r\nStation4: N51 21.789 / E07 02.800\r\nStation5: N51 21.667 / E07 02.800\r\nStation6: N51 21.444 / E07 02.706\r\nStation7: N51 21.321 / E07 02.700\r\nStation8: N51 21.123 / E07 02.477\r\nStation9: N51 21.734 / E07 02.500\r\nStation10: N51 21.733 / E07 02.378\r\nFinal: N51 21.544 / E07 02.566"); } - private static void assertWaypointsFromNote(final cgCache cache, Geopoint[] expected, String note) { + @MediumTest + public static void testEditModifiedCoordinates() { + final Geocache cache = new Geocache(); + cache.setGeocode("GC2ZN4G"); + // upload coordinates + GCParser.editModifiedCoordinates(cache, new Geopoint("N51 21.544", "E07 02.566")); + cache.drop(new Handler()); + final String page = GCParser.requestHtmlPage(cache.getGeocode(), null, "n", "0"); + final Geocache cache2 = GCParser.parseCacheFromText(page, null).getFirstCacheFromResult(LoadFlags.LOAD_CACHE_ONLY); + assertTrue(cache2.hasUserModifiedCoords()); + assertEquals(new Geopoint("N51 21.544", "E07 02.566"), cache2.getCoords()); + // delete coordinates + GCParser.deleteModifiedCoordinates(cache2); + cache2.drop(new Handler()); + final String page2 = GCParser.requestHtmlPage(cache.getGeocode(), null, "n", "0"); + final Geocache cache3 = GCParser.parseCacheFromText(page2, null).getFirstCacheFromResult(LoadFlags.LOAD_CACHE_ONLY); + assertFalse(cache3.hasUserModifiedCoords()); + } + + private static void assertWaypointsFromNote(final Geocache cache, Geopoint[] expected, String note) { cache.setPersonalNote(note); - cache.setWaypoints(new ArrayList<cgWaypoint>(), false); + cache.setWaypoints(new ArrayList<Waypoint>(), false); cache.parseWaypointsFromNote(); assertEquals(expected.length, cache.getWaypoints().size()); for (int i = 0; i < expected.length; i++) { @@ -132,16 +180,16 @@ public class GCParserTest extends AbstractResourceInstrumentationTestCase { } public void testWaypointParsing() { - cgCache cache = parseCache(R.raw.gc366bq); + Geocache cache = parseCache(R.raw.gc366bq); assertEquals(13, cache.getWaypoints().size()); //make sure that waypoints are not duplicated cache = parseCache(R.raw.gc366bq); assertEquals(13, cache.getWaypoints().size()); } - private cgCache parseCache(int resourceId) { + private Geocache parseCache(int resourceId) { final String page = getFileContent(resourceId); - SearchResult result = GCParser.parseCacheFromText(page, null); + final SearchResult result = GCParser.parseCacheFromText(page, null); assertNotNull(result); assertFalse(result.isEmpty()); return result.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB); diff --git a/tests/src/cgeo/geocaching/connector/gc/IconDecoderTest.java b/tests/src/cgeo/geocaching/connector/gc/IconDecoderTest.java index 3fa17f8..42028d8 100644 --- a/tests/src/cgeo/geocaching/connector/gc/IconDecoderTest.java +++ b/tests/src/cgeo/geocaching/connector/gc/IconDecoderTest.java @@ -1,6 +1,6 @@ package cgeo.geocaching.connector.gc; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.test.AbstractResourceInstrumentationTestCase; import cgeo.geocaching.test.R; @@ -15,10 +15,10 @@ public class IconDecoderTest extends AbstractResourceInstrumentationTestCase { final Bitmap bitmap = getBitmap(R.raw.tile14); Log.d("Bitmap=" + bitmap.getWidth() + "x" + bitmap.getHeight()); - assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 97, 136, 14).getType()); - assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 226, 104, 14).getType()); - assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 54, 97, 14).getType()); - assertTrue(parseMapPNG(bitmap, 119, 108, 14).isFound()); + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 88, 124, 14).getType()); + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 228, 104, 14).getType()); + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 52, 92, 14).getType()); + assertTrue(parseMapPNG(bitmap, 108, 112, 14).isFound()); } private Bitmap getBitmap(int resourceId) { @@ -29,8 +29,9 @@ public class IconDecoderTest extends AbstractResourceInstrumentationTestCase { return bitmap; } - private static cgCache parseMapPNG(Bitmap bitmap, int x, int y, int zoomlevel) { - final cgCache cache = new cgCache(); + private static Geocache parseMapPNG(Bitmap bitmap, int x, int y, int zoomlevel) { + final Geocache cache = new Geocache(); + cache.setGeocode("GC30"); IconDecoder.parseMapPNG(cache, bitmap, new UTFGridPosition(x / 4, y / 4), zoomlevel); return cache; } @@ -58,7 +59,7 @@ public class IconDecoderTest extends AbstractResourceInstrumentationTestCase { int mystery = 0; mystery = parseMapPNG(bitmap, 37, 25, 12).getType() == CacheType.MYSTERY ? mystery + 1 : mystery; mystery = parseMapPNG(bitmap, 49, 183, 12).getType() == CacheType.MYSTERY ? mystery + 1 : mystery; - mystery = parseMapPNG(bitmap, 183, 181, 12).getType() == CacheType.MYSTERY ? mystery + 1 : mystery; + mystery = parseMapPNG(bitmap, 184, 181, 12).getType() == CacheType.MYSTERY ? mystery + 1 : mystery; mystery = parseMapPNG(bitmap, 176, 94, 12).getType() == CacheType.MYSTERY ? mystery + 1 : mystery; mystery = parseMapPNG(bitmap, 161, 124, 12).getType() == CacheType.MYSTERY ? mystery + 1 : mystery; mystery = parseMapPNG(bitmap, 168, 118, 12).getType() == CacheType.MYSTERY ? mystery + 1 : mystery; @@ -73,9 +74,351 @@ public class IconDecoderTest extends AbstractResourceInstrumentationTestCase { tradi = parseMapPNG(bitmap, 117, 225, 12).getType() == CacheType.TRADITIONAL ? tradi + 1 : tradi; tradi = parseMapPNG(bitmap, 90, 107, 12).getType() == CacheType.TRADITIONAL ? tradi + 1 : tradi; + int found = 0; + found = parseMapPNG(bitmap, 150, 124, 12).isFound() ? found + 1 : found; + found = parseMapPNG(bitmap, 176, 82, 12).isFound() ? found + 1 : found; + found = parseMapPNG(bitmap, 240, 140, 12).isFound() ? found + 1 : found; + found = parseMapPNG(bitmap, 211, 127, 12).isFound() ? found + 1 : found; + assertEquals(7, multi); assertEquals(7, mystery); assertEquals(7, tradi); + assertEquals(4, found); + } + + public void testParseExtraMap1() { + final Bitmap bitmap = getBitmap(R.raw.map1); + assertTrue(parseMapPNG(bitmap, 128, 168, 12).isFound()); // GC3AT8B + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 172, 164, 12).getType()); // GC39EXB + assertTrue(parseMapPNG(bitmap, 164, 156, 12).isFound()); // GC30M7M + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 204, 72, 12).getType()); // GC3AN5Z + assertTrue(parseMapPNG(bitmap, 188, 92, 12).isFound()); // GC37T3R + assertTrue(parseMapPNG(bitmap, 164, 132, 12).isFound()); // GC34JME + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 176, 148, 12).getType()); // GC37TCY + assertEquals(CacheType.EARTH, parseMapPNG(bitmap, 180, 136, 12).getType()); // GC3947Z + assertTrue(parseMapPNG(bitmap, 164, 100, 12).isFound()); // GC2ZY3X + assertTrue(parseMapPNG(bitmap, 52, 104, 12).isFound()); // GC29RCW + assertTrue(parseMapPNG(bitmap, 168, 88, 12).isFound()); // GC264JZ + assertTrue(parseMapPNG(bitmap, 168, 140, 12).isFound()); // GC37RRV + } + + public void testParseExtraMap2() { + final Bitmap bitmap = getBitmap(R.raw.map2); + + assertTrue(parseMapPNG(bitmap, 132, 136, 12).isFound()); // GC3JDBW + assertTrue(parseMapPNG(bitmap, 68, 24, 12).isFound()); // GC2T0AH + assertTrue(parseMapPNG(bitmap, 176, 232, 12).isOwner()); // GC2RPBX + assertTrue(parseMapPNG(bitmap, 148, 60, 12).isFound()); // GC31FY6 + assertTrue(parseMapPNG(bitmap, 216, 20, 12).isFound()); // GC2KP3M + assertTrue(parseMapPNG(bitmap, 212, 184, 12).isOwner()); // GC30W3K + assertTrue(parseMapPNG(bitmap, 148, 72, 12).isOwner()); // GC2RPAZ + assertTrue(parseMapPNG(bitmap, 216, 48, 12).isOwner()); // GC2RP8W + assertTrue(parseMapPNG(bitmap, 212, 60, 12).isFound()); // GC3CC97 + assertTrue(parseMapPNG(bitmap, 148, 100, 12).isOwner()); // GC2RPAT + assertTrue(parseMapPNG(bitmap, 104, 136, 12).isFound()); // GC3AE31 + assertTrue(parseMapPNG(bitmap, 52, 96, 12).isOwner()); // GC2RPCH + assertTrue(parseMapPNG(bitmap, 172, 156, 12).isOwner()); // GC2RQ07 + assertTrue(parseMapPNG(bitmap, 116, 56, 12).isFound()); // GC3AYR2 + assertTrue(parseMapPNG(bitmap, 208, 68, 12).isOwner()); // GC2RP93 + assertTrue(parseMapPNG(bitmap, 200, 52, 12).isOwner()); // GC2RPAA + assertTrue(parseMapPNG(bitmap, 208, 44, 12).isFound()); // GC3HE15 + assertTrue(parseMapPNG(bitmap, 112, 76, 12).isOwner()); // GC2RPBE + assertTrue(parseMapPNG(bitmap, 232, 192, 12).isOwner()); // GC2E1KF + assertTrue(parseMapPNG(bitmap, 184, 76, 12).isFound()); // GC2NK5R + assertTrue(parseMapPNG(bitmap, 132, 148, 12).isOwner()); // GC2RPBC + } + + public void testParseExtraMap3() { + final Bitmap bitmap = getBitmap(R.raw.map3); + + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 44, 0, 12).getType()); // GC1THF5 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 176, 100, 12).getType()); // GC29EGE + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 212, 128, 12).getType()); // GC1VR64 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 220, 56, 12).getType()); // GC1M13A + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 120, 80, 12).getType()); // GC1ZA2Z + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 148, 56, 12).getType()); // GC1MRD8 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 252, 8, 12).getType()); // GC3AGEX + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 76, 108, 12).getType()); // GC2C5RB + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 228, 188, 12).getType()); // GC33TWE + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 232, 128, 12).getType()); // GC38QDJ + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 228, 160, 12).getType()); // GC2G8M1 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 184, 64, 12).getType()); // GC2FYH4 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 60, 132, 12).getType()); // GC299CV + assertEquals(CacheType.EVENT, parseMapPNG(bitmap, 244, 124, 12).getType()); // GC3E5FW + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 200, 160, 12).getType()); // GC29NR9 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 216, 116, 12).getType()); // GC17P5R + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 144, 92, 12).getType()); // GC1WYN3 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 80, 4, 12).getType()); // GC2Z90W + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 216, 148, 12).getType()); // GC29M3P + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 176, 148, 12).getType()); // GC2HJ88 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 68, 72, 12).getType()); // GC1VRB4 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 232, 100, 12).getType()); // GC29EG4 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 220, 68, 12).getType()); // GC2YXH8 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 248, 156, 12).getType()); // GC1F277 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 208, 80, 12).getType()); // GC2NV6T + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 60, 92, 12).getType()); // GC2Y2YY + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 188, 168, 12).getType()); // GC26RT7 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 224, 124, 12).getType()); // GC1ZBPC + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 144, 80, 12).getType()); // GC29NQJ + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 192, 124, 12).getType()); // GC1QRAP + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 104, 116, 12).getType()); // GC29NR1 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 240, 44, 12).getType()); // GC35KYR + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 168, 0, 12).getType()); // GC1VR78 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 200, 84, 12).getType()); // GC2YR8Z + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 52, 160, 12).getType()); // GC1MTD8 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 236, 156, 12).getType()); // GCYW8A + + } + + public void testParseExtraMap4() { + final Bitmap bitmap = getBitmap(R.raw.map4); + + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 124, 84, 12).getType()); // GC2M3CD + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 92, 140, 12).getType()); // GC1W2A2 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 156, 108, 12).getType()); // GC3FR70 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 44, 72, 12).getType()); // GC10W91 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 104, 36, 12).getType()); // GCRC1W + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 88, 36, 12).getType()); // GC30PQF + assertTrue(parseMapPNG(bitmap, 116, 36, 12).isFound()); // GC17VWA + assertEquals(CacheType.EARTH, parseMapPNG(bitmap, 28, 56, 12).getType()); // GC1E6A6 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 96, 72, 12).getType()); // GCMVAC + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 140, 48, 12).getType()); // GCZPE4 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 88, 84, 12).getType()); // GC16G8B + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 116, 48, 12).getType()); // GCZPEB + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 148, 8, 12).getType()); // GC19QQ4 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 68, 124, 12).getType()); // GCXJGD + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 88, 156, 12).getType()); // GC1VNAE + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 24, 24, 12).getType()); // GC1AY4H + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 180, 60, 12).getType()); // GC3K4HB + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 56, 104, 12).getType()); // GC2M4EH + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 12, 132, 12).getType()); // GC2B92G + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 240, 180, 12).getType()); // GC2YJ88 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 220, 140, 12).getType()); // GC2AWBC + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 124, 44, 12).getType()); // GC16V66 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 116, 104, 12).getType()); // GC2MN5V + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 212, 4, 12).getType()); // GC3BF7V + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 168, 40, 12).getType()); // GC1PB21 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 252, 56, 12).getType()); // GC22VTB + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 108, 64, 12).getType()); // GCVE3B + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 20, 140, 12).getType()); // GC1R041 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 124, 244, 12).getType()); // GC3DWEA + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 240, 136, 12).getType()); // GC249ZE + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 124, 56, 12).getType()); // GC1X0XJ + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 56, 16, 12).getType()); // GC2ZVGB + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 164, 164, 12).getType()); // GC3D65W + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 240, 128, 12).getType()); // GC33KV9 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 220, 244, 12).getType()); // GC21VT0 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 84, 24, 12).getType()); // GC1949K + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 104, 88, 12).getType()); // GC1FKZY + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 56, 248, 12).getType()); // GC2Y5Z4 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 72, 32, 12).getType()); // GC395J6 + assertTrue(parseMapPNG(bitmap, 180, 4, 12).isFound()); // GC21MFG + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 96, 100, 12).getType()); // GC1W45E + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 144, 160, 12).getType()); // GC37BA1 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 12, 4, 12).getType()); // GC1K8KR + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 172, 92, 12).getType()); // GC3EZZ4 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 188, 132, 12).getType()); // GC26T9J + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 68, 192, 12).getType()); // GC1ZAMG + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 176, 180, 12).getType()); // GC21EZE + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 172, 76, 12).getType()); // GC1G5PT + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 208, 112, 12).getType()); // GC132VV + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 156, 40, 12).getType()); // GC264J4 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 252, 140, 12).getType()); // GC2JBNE + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 112, 76, 12).getType()); // GC16VKJ + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 16, 156, 12).getType()); // GC2ADX3 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 68, 48, 12).getType()); // GC2AZT1 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 176, 252, 12).getType()); // GC3DWNM + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 4, 156, 12).getType()); // GC30VHE + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 156, 120, 12).getType()); // GC1T9WM + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 40, 48, 12).getType()); // GC30MTZ + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 180, 232, 12).getType()); // GC2XVQA + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 72, 92, 12).getType()); // GC1VVA9 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 0, 132, 12).getType()); // GC1XNN4 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 92, 192, 12).getType()); // GC11D9P + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 52, 84, 12).getType()); // GC2M693 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 176, 196, 12).getType()); // GCZHVE + assertTrue(parseMapPNG(bitmap, 140, 108, 12).isFound()); // GC1Q5PW + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 108, 148, 12).getType()); // GC2ZR0C + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 168, 8, 12).getType()); // GCYWQH + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 196, 92, 12).getType()); // GC39VXN + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 148, 136, 12).getType()); // GC2MM6C + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 168, 28, 12).getType()); // GC2H1TG + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 240, 52, 12).getType()); // GC2QTXT + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 152, 148, 12).getType()); // GC3E7QD + assertTrue(parseMapPNG(bitmap, 160, 60, 12).isFound()); // GC2J3G9 + assertTrue(parseMapPNG(bitmap, 160, 100, 12).isFound()); // GC2327G + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 136, 32, 12).getType()); // GC2JVEH + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 208, 164, 12).getType()); // GC1NN15 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 84, 244, 12).getType()); // GC3E5JP + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 172, 16, 12).getType()); // GC1Z581 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 104, 20, 12).getType()); // GC2MENX + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 144, 60, 12).getType()); // GC1V3MG + assertTrue(parseMapPNG(bitmap, 228, 56, 12).isFound()); // GC36WZN + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 144, 212, 12).getType()); // GCR9GB + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 180, 68, 12).getType()); // GC3JZ1K + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 228, 104, 12).getType()); // GCQ95T + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 84, 220, 12).getType()); // GCWTVM + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 200, 228, 12).getType()); // GC3CC1A + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 204, 56, 12).getType()); // GC1K0WX + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 244, 208, 12).getType()); // GC1JVXG + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 84, 128, 12).getType()); // GC2XQ6C + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 248, 164, 12).getType()); // GC3B1JK + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 232, 84, 12).getType()); // GC3AT8J + assertTrue(parseMapPNG(bitmap, 160, 88, 12).isFound()); // GC2MB4P + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 132, 20, 12).getType()); // GC2NW3F + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 56, 132, 12).getType()); // GC22ERA + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 28, 32, 12).getType()); // GC2EFFK + } + + public void testParseExtraMap5() { + final Bitmap bitmap = getBitmap(R.raw.map5); + + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 60, 32, 12).getType()); // GC31DNK + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 200, 120, 12).getType()); // GCP89K + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 144, 152, 12).getType()); // GC22AR8 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 164, 92, 12).getType()); // GC1MFB7 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 16, 212, 12).getType()); // GC12F2K + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 188, 12, 12).getType()); // GC24J14 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 36, 72, 12).getType()); // GC2J8MY + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 152, 140, 12).getType()); // GC1H9WQ + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 44, 40, 12).getType()); // GC31DNZ + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 8, 152, 12).getType()); // GC34YFB + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 200, 216, 12).getType()); // GC30MK5 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 84, 20, 12).getType()); // GC304YY + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 192, 236, 12).getType()); // GC1D6AC + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 220, 48, 12).getType()); // GC1HQ8Y + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 136, 176, 12).getType()); // GC310B7 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 132, 232, 12).getType()); // GC12CR5 + assertTrue(parseMapPNG(bitmap, 240, 40, 12).isFound()); // GC24GW1 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 140, 116, 12).getType()); // GC2YYE7 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 124, 144, 12).getType()); // GC111RZ + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 48, 128, 12).getType()); // GC13A7V + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 136, 92, 12).getType()); // GC2BKW9 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 200, 184, 12).getType()); // GC30X0C + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 156, 200, 12).getType()); // GC17V4A + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 160, 120, 12).getType()); // GC2ZBWW + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 196, 36, 12).getType()); // GC14X25 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 192, 100, 12).getType()); // GC1HXAX + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 108, 168, 12).getType()); // GC3C043 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 232, 28, 12).getType()); // GC1TEAR + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 200, 204, 12).getType()); // GC3AKFV + assertTrue(parseMapPNG(bitmap, 228, 28, 12).isFound()); // GC2NMPR + //assertEquals(CacheType.VIRTUAL, parseMapPNG(bitmap, 232, 252, 12).getType()); // GC1AH0N - False detection + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 220, 188, 12).getType()); // GC1ZXDK + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 168, 212, 12).getType()); // GC3A919 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 152, 176, 12).getType()); // GC196WN + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 144, 180, 12).getType()); // GC12RE5 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 176, 116, 12).getType()); // GC1DY2M + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 44, 212, 12).getType()); // GC3MRNT + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 220, 36, 12).getType()); // GC3CWZD + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 48, 160, 12).getType()); // GC1A8E3 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 8, 252, 12).getType()); // GC10W6W + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 60, 92, 12).getType()); // GC2D9DD + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 96, 164, 12).getType()); // GC1Z4QX + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 220, 252, 12).getType()); // GCNEGK + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 32, 188, 12).getType()); // GC10916 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 204, 224, 12).getType()); // GC1CA2Y + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 120, 236, 12).getType()); // GC11B3J + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 248, 24, 12).getType()); // GCKX8C + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 128, 152, 12).getType()); // GC2V6AA + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 196, 48, 12).getType()); // GC2YG95 + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 48, 64, 12).getType()); // GCHGR8 + assertEquals(CacheType.EVENT, parseMapPNG(bitmap, 188, 96, 12).getType()); // GC3KBPK + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 208, 140, 12).getType()); // GC1C9B0 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 164, 100, 12).getType()); // GC29JGA + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 156, 28, 12).getType()); // GCN690 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 232, 20, 12).getType()); // GC18Z53 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 220, 152, 12).getType()); // GC18RB6 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 200, 248, 12).getType()); // GC2378H + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 248, 244, 12).getType()); // GCV8QA + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 12, 232, 12).getType()); // GC2MXDG + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 48, 248, 12).getType()); // GCTHJR + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 216, 200, 12).getType()); // GC1EPM5 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 232, 60, 12).getType()); // GC2N0PB + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 88, 56, 12).getType()); // GC1ZWNX + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 248, 56, 12).getType()); // GC1N11P + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 100, 180, 12).getType()); // GCM6AE + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 220, 124, 12).getType()); // GC2A1RQ + assertTrue(parseMapPNG(bitmap, 212, 4, 12).isFound()); // GC1TVKE + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 28, 212, 12).getType()); // GC2A1RR + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 128, 84, 12).getType()); // GC16AWC + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 220, 16, 12).getType()); // GC282V9 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 112, 240, 12).getType()); // GC18VT5 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 80, 248, 12).getType()); // GC10YEK + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 224, 228, 12).getType()); // GC1EA70 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 232, 244, 12).getType()); // GC14PNY + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 108, 32, 12).getType()); // GC2MMPN + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 144, 188, 12).getType()); // GC1CCF4 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 228, 208, 12).getType()); // GCV8C2 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 104, 252, 12).getType()); // GCTRPF + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 176, 92, 12).getType()); // GCRF8G + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 120, 140, 12).getType()); // GC210B9 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 204, 240, 12).getType()); // GC16NTW + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 192, 224, 12).getType()); // GC2PTVN + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 76, 116, 12).getType()); // GC1RPG0 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 144, 200, 12).getType()); // GC1FZ4T + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 172, 36, 12).getType()); // GC1ZYG8 + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 248, 196, 12).getType()); // GC17FJQ + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 88, 140, 12).getType()); // GC1KWK0 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 168, 196, 12).getType()); // GC17MNG + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 20, 252, 12).getType()); // GC13M6V + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 120, 172, 12).getType()); // GC3B30A + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 104, 92, 12).getType()); // GC2GY9D + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 128, 120, 12).getType()); // GC2Y90M + assertTrue(parseMapPNG(bitmap, 204, 40, 12).isFound()); // GC1BZ6P + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 56, 76, 12).getType()); // GC10K7X + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 196, 108, 12).getType()); // GC1F0R5 + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 120, 196, 12).getType()); // GC1KQQW + } + + public void testParseExtraMap11() { + final Bitmap bitmap = getBitmap(R.raw.map11); + assertEquals(CacheType.EVENT, parseMapPNG(bitmap, 132, 16, 11).getType()); + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 104, 48, 11).getType()); + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 128, 124, 11).getType()); + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 228, 8, 11).getType()); + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 160, 156, 11).getType()); + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 208, 176, 11).getType()); + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 252, 24, 11).getType()); + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 216, 96, 11).getType()); + assertEquals(CacheType.EARTH, parseMapPNG(bitmap, 24, 212, 11).getType()); + } + + public void testParseExtraMapall14() { + final Bitmap bitmap = getBitmap(R.raw.map_all14); + assertTrue(parseMapPNG(bitmap, 40, 16, 14).isFound()); + assertTrue(parseMapPNG(bitmap, 72, 16, 14).isFound()); + assertTrue(parseMapPNG(bitmap, 100, 16, 14).isFound()); + assertTrue(parseMapPNG(bitmap, 128, 16, 14).isFound()); + assertTrue(parseMapPNG(bitmap, 44, 44, 14).isOwner()); + assertTrue(parseMapPNG(bitmap, 76, 44, 14).isOwner()); + assertTrue(parseMapPNG(bitmap, 132, 44, 14).isOwner()); + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 40, 72, 14).getType()); + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 72, 72, 14).getType()); + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 100, 72, 14).getType()); + assertEquals(CacheType.MULTI, parseMapPNG(bitmap, 128, 72, 14).getType()); + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 40, 96, 14).getType()); + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 72, 96, 14).getType()); + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 100, 96, 14).getType()); + assertEquals(CacheType.MYSTERY, parseMapPNG(bitmap, 128, 96, 14).getType()); + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 40, 124, 14).getType()); + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 72, 124, 14).getType()); + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 100, 124, 14).getType()); + assertEquals(CacheType.TRADITIONAL, parseMapPNG(bitmap, 128, 124, 14).getType()); + assertEquals(CacheType.WHERIGO, parseMapPNG(bitmap, 40, 160, 14).getType()); + assertEquals(CacheType.WHERIGO, parseMapPNG(bitmap, 72, 160, 14).getType()); + assertEquals(CacheType.WHERIGO, parseMapPNG(bitmap, 100, 160, 14).getType()); + assertEquals(CacheType.WHERIGO, parseMapPNG(bitmap, 128, 160, 14).getType()); + assertEquals(CacheType.LETTERBOX, parseMapPNG(bitmap, 40, 184, 14).getType()); + assertEquals(CacheType.LETTERBOX, parseMapPNG(bitmap, 72, 184, 14).getType()); + assertEquals(CacheType.LETTERBOX, parseMapPNG(bitmap, 100, 184, 14).getType()); + assertEquals(CacheType.LETTERBOX, parseMapPNG(bitmap, 128, 184, 14).getType()); + assertEquals(CacheType.CITO, parseMapPNG(bitmap, 12, 224, 14).getType()); + assertEquals(CacheType.EVENT, parseMapPNG(bitmap, 40, 220, 14).getType()); + assertEquals(CacheType.EARTH, parseMapPNG(bitmap, 68, 224, 14).getType()); + assertEquals(CacheType.MEGA_EVENT, parseMapPNG(bitmap, 96, 224, 14).getType()); + assertEquals(CacheType.WEBCAM, parseMapPNG(bitmap, 120, 224, 14).getType()); + assertEquals(CacheType.VIRTUAL, parseMapPNG(bitmap, 144, 224, 14).getType()); } } diff --git a/tests/src/cgeo/geocaching/connector/gc/TrackablesTest.java b/tests/src/cgeo/geocaching/connector/gc/TrackablesTest.java index 319a3b2..cd130db 100644 --- a/tests/src/cgeo/geocaching/connector/gc/TrackablesTest.java +++ b/tests/src/cgeo/geocaching/connector/gc/TrackablesTest.java @@ -1,8 +1,10 @@ package cgeo.geocaching.connector.gc; +import cgeo.geocaching.Image; import cgeo.geocaching.LogEntry; import cgeo.geocaching.TrackableLog; -import cgeo.geocaching.cgTrackable; +import cgeo.geocaching.Trackable; +import cgeo.geocaching.enumerations.LogType; import cgeo.geocaching.test.AbstractResourceInstrumentationTestCase; import cgeo.geocaching.test.R; import cgeo.geocaching.utils.BaseUtils; @@ -12,51 +14,65 @@ import java.util.List; public class TrackablesTest extends AbstractResourceInstrumentationTestCase { public void testLogPageWithTrackables() { - List<TrackableLog> tbLogs = GCParser.parseTrackableLog(getFileContent(R.raw.log_with_2tb)); + final List<TrackableLog> tbLogs = GCParser.parseTrackableLog(getFileContent(R.raw.log_with_2tb)); assertNotNull(tbLogs); assertEquals(2, tbLogs.size()); - TrackableLog log = tbLogs.get(0); + final TrackableLog log = tbLogs.get(0); assertEquals("Steffen's Kaiserwagen", log.name); assertEquals("1QG1EE", log.trackCode); } public void testLogPageWithoutTrackables() { - List<TrackableLog> tbLogs = GCParser.parseTrackableLog(getFileContent(R.raw.log_without_tb)); + final List<TrackableLog> tbLogs = GCParser.parseTrackableLog(getFileContent(R.raw.log_without_tb)); assertNotNull(tbLogs); assertEquals(0, tbLogs.size()); } public void testTrackable() { - final cgTrackable trackable = getTB2R124(); + final Trackable trackable = getTB2R124(); assertEquals("TB2R124", trackable.getGeocode()); assertEquals("Bor. Dortmund - FC Schalke 04", trackable.getName()); assertEquals("Spiridon Lui", trackable.getOwner()); } public void testTrackableWithoutImage() { - final cgTrackable trackable = getTB2R124(); + final Trackable trackable = getTB2R124(); assertNull(trackable.getImage()); assertNotNull(trackable.getDetails()); } public void testTrackableWithLogImages() { - final cgTrackable trackable = getTBXATG(); + final Trackable trackable = getTBXATG(); assertEquals("TBXATG", trackable.getGeocode()); - List<LogEntry> log = trackable.getLogs(); - // second log entry has several images; just check first two - assertEquals("http://img.geocaching.com/track/log/large/f2e24c50-394c-4d74-8fb4-87298d8bff1d.jpg", log.get(4).getLogImages().get(0).getUrl()); - assertEquals("7b Welcome to Geowoodstock", log.get(4).getLogImages().get(0).getTitle()); - assertEquals("http://img.geocaching.com/track/log/large/b57c29c3-134e-4202-a2a1-69ce8920b055.jpg", log.get(4).getLogImages().get(1).getUrl()); - assertEquals("8 Crater Lake Natl Park Oregon", log.get(4).getLogImages().get(1).getTitle()); + final List<LogEntry> log = trackable.getLogs(); + assertNotNull(log); + assertEquals(10, log.size()); + // log entry 4 has several images; just check first two + + final List<Image> log4Images = log.get(4).getLogImages(); + assertNotNull(log4Images); + assertEquals(5, log4Images.size()); + assertEquals("http://img.geocaching.com/track/log/large/f2e24c50-394c-4d74-8fb4-87298d8bff1d.jpg", log4Images.get(0).getUrl()); + assertEquals("7b Welcome to Geowoodstock", log4Images.get(0).getTitle()); + assertEquals("http://img.geocaching.com/track/log/large/b57c29c3-134e-4202-a2a1-69ce8920b055.jpg", log4Images.get(1).getUrl()); + assertEquals("8 Crater Lake Natl Park Oregon", log4Images.get(1).getTitle()); // third log entry has one image - assertEquals("http://img.geocaching.com/track/log/large/0096b42d-4d10-45fa-9be2-2d08c0d5cc61.jpg", log.get(5).getLogImages().get(0).getUrl()); - assertEquals("Traverski's GC Univ coin on tour", log.get(5).getLogImages().get(0).getTitle()); + final List<Image> log5Images = log.get(5).getLogImages(); + assertNotNull(log5Images); + assertEquals(1, log5Images.size()); + assertEquals("http://img.geocaching.com/track/log/large/0096b42d-4d10-45fa-9be2-2d08c0d5cc61.jpg", log5Images.get(0).getUrl()); + assertEquals("Traverski's GC Univ coin on tour", log5Images.get(0).getTitle()); + + for (LogEntry entry : log) { + assertFalse(entry.log.startsWith("<div>")); + } + assertEquals("traveling", log.get(0).log); } public void testParseTrackableWithoutReleaseDate() { - cgTrackable trackable = GCParser.parseTrackable(getFileContent(R.raw.tb14wfv), null); + final Trackable trackable = parseTrackable(R.raw.tb14wfv); assertNotNull(trackable); assertEquals("The Brickster", trackable.getName()); assertEquals("Adrian C", trackable.getOwner()); @@ -69,7 +85,7 @@ public class TrackablesTest extends AbstractResourceInstrumentationTestCase { } public void testParseRelativeLink() { - final cgTrackable trackable = GCParser.parseTrackable(getFileContent(R.raw.tb4cwjx), null); + final Trackable trackable = parseTrackable(R.raw.tb4cwjx); assertNotNull(trackable); assertEquals("The Golden Lisa", trackable.getName()); final String goal = trackable.getGoal(); @@ -78,16 +94,31 @@ public class TrackablesTest extends AbstractResourceInstrumentationTestCase { assertTrue(goal.contains("href=\"http://www.geocaching.com/seek/cache_details.aspx?wp=GC3B7PD#\"")); } - private cgTrackable getTB2R124() { - return GCParser.parseTrackable(BaseUtils.replaceWhitespace(getFileContent(R.raw.trackable_tb2r124)), null); + private Trackable parseTrackable(int trackablePage) { + final String pageContent = getFileContent(trackablePage); + return GCParser.parseTrackable(BaseUtils.replaceWhitespace(pageContent), null); + } + + public void testParseMarkMissing() { + final Trackable trackable = parseTrackable(R.raw.tb29ggq); + assertNotNull(trackable); + final List<LogEntry> logs = trackable.getLogs(); + assertNotNull(logs); + assertFalse(logs.isEmpty()); + final LogEntry marked = logs.get(4); + assertEquals(LogType.MARKED_MISSING, marked.type); + } + + private Trackable getTB2R124() { + return parseTrackable(R.raw.trackable_tb2r124); } - private cgTrackable getTBXATG() { - return GCParser.parseTrackable(BaseUtils.replaceWhitespace(getFileContent(R.raw.trackable_tbxatg)), null); + private Trackable getTBXATG() { + return parseTrackable(R.raw.trackable_tbxatg); } public void testParseTrackableNotExisting() { - cgTrackable trackable = GCParser.parseTrackable(getFileContent(R.raw.tb_not_existing), null); + final Trackable trackable = GCParser.parseTrackable(getFileContent(R.raw.tb_not_existing), null); assertNull(trackable); } diff --git a/tests/src/cgeo/geocaching/connector/gc/WaypointsTest.java b/tests/src/cgeo/geocaching/connector/gc/WaypointsTest.java new file mode 100644 index 0000000..d186526 --- /dev/null +++ b/tests/src/cgeo/geocaching/connector/gc/WaypointsTest.java @@ -0,0 +1,35 @@ +package cgeo.geocaching.connector.gc; + +import cgeo.CGeoTestCase; +import cgeo.geocaching.Geocache; +import cgeo.geocaching.SearchResult; +import cgeo.geocaching.cgData; +import cgeo.geocaching.enumerations.LoadFlags; +import cgeo.geocaching.utils.CancellableHandler; + +import android.os.Message; + +public class WaypointsTest extends CGeoTestCase { + + public static final CancellableHandler handler = new CancellableHandler() { + @Override + protected void handleRegularMessage(final Message message) { + // Dummy + } + }; + + private static Geocache downloadCache(final String geocode) { + final SearchResult searchResult = Geocache.searchByGeocode(geocode, null, 0, true, handler); + assertEquals(1, searchResult.getCount()); + return searchResult.getFirstCacheFromResult(LoadFlags.LOAD_WAYPOINTS); + } + + public static void testDownloadWaypoints() { + // Check that repeated loads of "GC33HXE" hold the right number of waypoints (issue #2430). + final String GEOCODE = "GC33HXE"; + cgData.removeCache(GEOCODE, LoadFlags.REMOVE_ALL); + assertEquals(9, downloadCache(GEOCODE).getWaypoints().size()); + assertEquals(9, downloadCache(GEOCODE).getWaypoints().size()); + } + +} diff --git a/tests/src/cgeo/geocaching/connector/oc/OCXMLTest.java b/tests/src/cgeo/geocaching/connector/oc/OCXMLTest.java new file mode 100644 index 0000000..b12823a --- /dev/null +++ b/tests/src/cgeo/geocaching/connector/oc/OCXMLTest.java @@ -0,0 +1,123 @@ +package cgeo.geocaching.connector.oc; + +import cgeo.CGeoTestCase; +import cgeo.geocaching.Geocache; +import cgeo.geocaching.Settings; +import cgeo.geocaching.enumerations.CacheType; + +import java.util.Collection; + +public class OCXMLTest extends CGeoTestCase { + + public static void testOCGetCache() { + final String geoCode = "OCDE76"; + + final Geocache cache = OCXMLClient.getCache(geoCode); + assertNotNull(cache); + assertEquals(geoCode, cache.getGeocode()); + assertEquals("Gitarrenspielplatz", cache.getName()); + assertEquals(CacheType.TRADITIONAL, cache.getType()); + assertEquals(2.0, cache.getDifficulty(), 0.1); + assertEquals(2.0, cache.getTerrain(), 0.1); + } + + public static void testOCLogAttendedAsFound() { + + final String oldOCName = Settings.getOCConnectorUserName(); + try { + Settings.setOCConnectorUserName("ra_sch"); + final String geoCode = "OCD541"; + final Geocache cache = OCXMLClient.getCache(geoCode); + assertNotNull(cache); + + assertTrue(cache.isFound()); + } finally { + Settings.setOCConnectorUserName(oldOCName); + } + } + + public static void testOCOwner() { + final String oldOCName = Settings.getOCConnectorUserName(); + try { + Settings.setOCConnectorUserName("andi12.2"); + final String geoCode = "OCC9BE"; + final Geocache cache = OCXMLClient.getCache(geoCode); + assertNotNull(cache); + + assertTrue(cache.isOwner()); + assertEquals("180571", cache.getOwnerUserId()); + } finally { + Settings.setOCConnectorUserName(oldOCName); + } + } + + public static void testOC0537Description() { + final String geoCode = "OC0537"; + final Geocache cache = OCXMLClient.getCache(geoCode); + assertNotNull(cache); + + assertFalse(cache.getDescription().length() < 100); + } + + public static void testNoArchivedInNearby() { + + final boolean oldExcludeDisabled = Settings.isExcludeDisabledCaches(); + final boolean oldExcludeMine = Settings.isExcludeMyCaches(); + try { + Settings.setExcludeDisabledCaches(false); + Settings.setExcludeMine(false); + // get an archived cache + final Geocache cache = OCXMLClient.getCache("OCD541"); + assertNotNull(cache); + assertTrue(cache.isArchived()); + // Get nearby for this cache + final Collection<Geocache> caches = OCXMLClient.getCachesAround(cache.getCoords(), 0.5); + // Should not be in the result! + assertFalse(caches.contains(cache)); + } finally { + Settings.setExcludeDisabledCaches(oldExcludeDisabled); + Settings.setExcludeMine(oldExcludeMine); + } + } + + public static void testFetchTwiceDuplicatesDescription() { + final String geoCode = "OCEFBA"; + final String description = "Bei dem Cache kannst du einen kleinen Schatz bergen. Bitte lege aber einen ander Schatz in das Döschen. Achtung vor Automuggels."; + + deleteCacheFromDB(geoCode); + Geocache cache = OCXMLClient.getCache(geoCode); + assertNotNull(cache); + try { + assertEquals(geoCode, cache.getGeocode()); + assertEquals(description, cache.getDescription()); + cache.store(null); + + // reload, make sure description is not duplicated + cache = OCXMLClient.getCache(geoCode); + assertNotNull(cache); + assertEquals(description, cache.getDescription()); + } finally { + deleteCacheFromDB(geoCode); + } + } + + public static void testRemoveMarkupCache() { + final String geoCode = "OCEFBA"; + final String description = "Bei dem Cache kannst du einen kleinen Schatz bergen. Bitte lege aber einen ander Schatz in das Döschen. Achtung vor Automuggels."; + + Geocache cache = OCXMLClient.getCache(geoCode); + assertNotNull(cache); + assertEquals(description, cache.getDescription()); + } + + public static void testRemoveMarkup() { + assertEquals("", OC11XMLParser.stripMarkup("")); + assertEquals("Test", OC11XMLParser.stripMarkup("Test")); + assertEquals("<b>bold and others not removed</b>", OC11XMLParser.stripMarkup("<b>bold and others not removed</b>")); + assertEquals("unnecessary paragraph", OC11XMLParser.stripMarkup("<p>unnecessary paragraph</p>")); + assertEquals("unnecessary span", OC11XMLParser.stripMarkup("<span>unnecessary span</span>")); + assertEquals("nested", OC11XMLParser.stripMarkup("<span><span>nested</span></span>")); + assertEquals("mixed", OC11XMLParser.stripMarkup("<span> <p> mixed </p> </span>")); + assertEquals("<p>not</p><p>removable</p>", OC11XMLParser.stripMarkup("<p>not</p><p>removable</p>")); + } +} diff --git a/tests/src/cgeo/geocaching/connector/opencaching/OkapiClientTest.java b/tests/src/cgeo/geocaching/connector/oc/OkapiClientTest.java index 5576028..690cd4c 100644 --- a/tests/src/cgeo/geocaching/connector/opencaching/OkapiClientTest.java +++ b/tests/src/cgeo/geocaching/connector/oc/OkapiClientTest.java @@ -1,23 +1,22 @@ -package cgeo.geocaching.connector.opencaching; +package cgeo.geocaching.connector.oc; import cgeo.CGeoTestCase; -import cgeo.geocaching.cgCache; -import cgeo.geocaching.cgeoapplication; +import cgeo.geocaching.Geocache; +import cgeo.geocaching.cgData; import cgeo.geocaching.connector.oc.OkapiClient; import cgeo.geocaching.enumerations.LoadFlags; public class OkapiClientTest extends CGeoTestCase { public static void testGetOCCache() { - String geoCode = "OU0331"; - cgCache cache = OkapiClient.getCache(geoCode); + final String geoCode = "OU0331"; + Geocache cache = OkapiClient.getCache(geoCode); assertNotNull(cache); 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/enumerations/CacheAttributeTest.java b/tests/src/cgeo/geocaching/enumerations/CacheAttributeTest.java index f369b0e..8d2d114 100644 --- a/tests/src/cgeo/geocaching/enumerations/CacheAttributeTest.java +++ b/tests/src/cgeo/geocaching/enumerations/CacheAttributeTest.java @@ -6,7 +6,7 @@ public class CacheAttributeTest extends AndroidTestCase { public static void testTrimAttributeName() { for (CacheAttribute attribute : CacheAttribute.values()) { - final String rawName = attribute.gcRawName; + final String rawName = attribute.rawName; assertTrue("bad attribute name " + rawName, CacheAttribute.trimAttributeName(rawName).equals(rawName)); } } @@ -14,10 +14,39 @@ public class CacheAttributeTest extends AndroidTestCase { public static void testIds() { for (CacheAttribute attribute : CacheAttribute.values()) { if (attribute != CacheAttribute.UNKNOWN) { + assertTrue(attribute.rawName != null); + assertTrue(attribute.rawName.length() > 0); assertTrue(attribute.drawableId != 0); assertTrue(attribute.stringIdYes != 0); assertTrue(attribute.stringIdNo != 0); } } } + + public static void testGetL10n() { + final CacheAttribute attribute = CacheAttribute.HIKING; + // This test is language dependend. It does not make sense to test it + // with every attribute. We just want to know if getL10n works + // correctly + assertFalse("_yes and _no must not have the same translation", + attribute.getL10n(true).equals(attribute.getL10n(false))); + } + + public static void testGetBy() { + final CacheAttribute attribute = CacheAttribute.HIKING; // an attribute that is present in GC and OC + assertTrue("Test cannot be run with this attribute", attribute.gcid >= 0); + assertTrue("Test cannot be run with this attribute", attribute.ocid >= 0); + assertSame(CacheAttribute.getByRawName(attribute.rawName), attribute); + assertSame(CacheAttribute.getByGcId(attribute.gcid), attribute); + assertSame(CacheAttribute.getByOcId(attribute.ocid), attribute); + } + + public static void testIsEnabled() { + final CacheAttribute attribute = CacheAttribute.HIKING; + final String hiking_yes = attribute.getAttributeName(true); + final String hiking_no = attribute.getAttributeName(false); + assertTrue(CacheAttribute.isEnabled(hiking_yes)); + assertFalse(CacheAttribute.isEnabled(hiking_no)); + } + } diff --git a/tests/src/cgeo/geocaching/enumerations/CacheSizeTest.java b/tests/src/cgeo/geocaching/enumerations/CacheSizeTest.java index c872c9d..9c3063d 100644 --- a/tests/src/cgeo/geocaching/enumerations/CacheSizeTest.java +++ b/tests/src/cgeo/geocaching/enumerations/CacheSizeTest.java @@ -2,6 +2,8 @@ package cgeo.geocaching.enumerations; import android.test.AndroidTestCase; +import java.util.Locale; + public class CacheSizeTest extends AndroidTestCase { public static void testOrder() { @@ -15,13 +17,14 @@ public class CacheSizeTest extends AndroidTestCase { assertEquals(CacheSize.UNKNOWN, CacheSize.getById(null)); assertEquals(CacheSize.UNKNOWN, CacheSize.getById("random garbage")); assertEquals(CacheSize.LARGE, CacheSize.getById("large")); + assertEquals(CacheSize.LARGE, CacheSize.getById("LARGE")); } public static void testGetByIdComplete() { for (CacheSize size : CacheSize.values()) { assertEquals(size, CacheSize.getById(size.id)); - assertEquals(size, CacheSize.getById(size.id.toLowerCase())); - assertEquals(size, CacheSize.getById(size.id.toUpperCase())); + assertEquals(size, CacheSize.getById(size.id.toLowerCase(Locale.US))); + assertEquals(size, CacheSize.getById(size.id.toUpperCase(Locale.US))); } } } diff --git a/tests/src/cgeo/geocaching/enumerations/CacheTypeTest.java b/tests/src/cgeo/geocaching/enumerations/CacheTypeTest.java index dd35669..96796f2 100644 --- a/tests/src/cgeo/geocaching/enumerations/CacheTypeTest.java +++ b/tests/src/cgeo/geocaching/enumerations/CacheTypeTest.java @@ -1,7 +1,11 @@ package cgeo.geocaching.enumerations; +import cgeo.geocaching.Geocache; + import android.test.AndroidTestCase; +import java.util.Locale; + public class CacheTypeTest extends AndroidTestCase { public static void testGetById() { @@ -21,16 +25,25 @@ public class CacheTypeTest extends AndroidTestCase { public static void testGetByIdComplete() { for (CacheType type : CacheType.values()) { assertEquals(type, CacheType.getById(type.id)); - assertEquals(type, CacheType.getById(type.id.toLowerCase())); - assertEquals(type, CacheType.getById(type.id.toUpperCase())); + assertEquals(type, CacheType.getById(type.id.toLowerCase(Locale.US))); + assertEquals(type, CacheType.getById(type.id.toUpperCase(Locale.US))); } } public static void testGetByPatternComplete() { for (CacheType type : CacheType.values()) { assertEquals(type, CacheType.getByPattern(type.pattern)); - assertEquals(type, CacheType.getByPattern(type.pattern.toLowerCase())); - assertEquals(type, CacheType.getByPattern(type.pattern.toUpperCase())); + assertEquals(type, CacheType.getByPattern(type.pattern.toLowerCase(Locale.US))); + assertEquals(type, CacheType.getByPattern(type.pattern.toUpperCase(Locale.US))); } } + + public static void testContainsCache() { + final Geocache traditional = new Geocache(); + traditional.setType(CacheType.TRADITIONAL); + + assertTrue(CacheType.ALL.contains(traditional)); + assertTrue(CacheType.TRADITIONAL.contains(traditional)); + assertFalse(CacheType.MYSTERY.contains(traditional)); + } } diff --git a/tests/src/cgeo/geocaching/enumerations/LogTypeTest.java b/tests/src/cgeo/geocaching/enumerations/LogTypeTest.java index 44f464e..81ca33b 100644 --- a/tests/src/cgeo/geocaching/enumerations/LogTypeTest.java +++ b/tests/src/cgeo/geocaching/enumerations/LogTypeTest.java @@ -19,7 +19,8 @@ public class LogTypeTest extends AndroidTestCase { public static void testGetByType() { assertEquals(LogType.UNKNOWN, LogType.getByIconName("")); assertEquals(LogType.UNKNOWN, LogType.getByIconName(null)); - assertEquals(LogType.GRABBED_IT, LogType.getByType("grabbed IT ")); + assertEquals(LogType.GRABBED_IT, LogType.getByType("grabbed it")); + assertEquals(LogType.GRABBED_IT, LogType.getByType(" gRAbbed IT ")); } } diff --git a/tests/src/cgeo/geocaching/export/ExportTest.java b/tests/src/cgeo/geocaching/export/ExportTest.java index cdd64b2..22c6dd2 100644 --- a/tests/src/cgeo/geocaching/export/ExportTest.java +++ b/tests/src/cgeo/geocaching/export/ExportTest.java @@ -1,14 +1,14 @@ package cgeo.geocaching.export; import cgeo.CGeoTestCase; +import cgeo.geocaching.Geocache; import cgeo.geocaching.LogEntry; -import cgeo.geocaching.cgCache; import cgeo.geocaching.enumerations.LogType; public class ExportTest extends CGeoTestCase { public static void testGSAKExport() { - final cgCache cache = new cgCache(); + final Geocache cache = new Geocache(); cache.setGeocode("GCX1234"); final LogEntry log = new LogEntry(1353244820000L, LogType.FOUND_IT, "Hidden in a tree"); final StringBuilder logStr = new StringBuilder(); diff --git a/tests/src/cgeo/geocaching/files/GPXImporterTest.java b/tests/src/cgeo/geocaching/files/GPXImporterTest.java index da99c11..86369a3 100644 --- a/tests/src/cgeo/geocaching/files/GPXImporterTest.java +++ b/tests/src/cgeo/geocaching/files/GPXImporterTest.java @@ -1,9 +1,9 @@ package cgeo.geocaching.files; +import cgeo.geocaching.Geocache; 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; @@ -30,10 +30,10 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { private boolean importWpStaticMaps; public void testGetWaypointsFileNameForGpxFile() throws IOException { - String[] gpxFiles = new String[] { "1234567.gpx", "1.gpx", "1234567.9.gpx", + final String[] gpxFiles = new String[] { "1234567.gpx", "1.gpx", "1234567.9.gpx", "1234567.GPX", "gpx.gpx.gpx", ".gpx", "1234567_query.gpx", "123-4.gpx", "123(5).gpx" }; - String[] wptsFiles = new String[] { "1234567-wpts.gpx", "1-wpts.gpx", "1234567.9-wpts.gpx", + final String[] wptsFiles = new String[] { "1234567-wpts.gpx", "1-wpts.gpx", "1234567.9-wpts.gpx", "1234567-wpts.GPX", "gpx.gpx-wpts.gpx", "-wpts.gpx", "1234567_query-wpts.gpx", "123-wpts-4.gpx", "123-wpts(5).gpx" }; for (int i = 0; i < gpxFiles.length; i++) { @@ -50,29 +50,28 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { gpx.delete(); wpts.delete(); } - File gpx1 = new File(tempDir, "abc.gpx"); + final File gpx1 = new File(tempDir, "abc.gpx"); assertNull(GPXImporter.getWaypointsFileNameForGpxFile(gpx1)); } public void testImportGpx() throws IOException { final String geocode = "GC31J2H"; removeCacheCompletely(geocode); - File gc31j2h = new File(tempDir, "gc31j2h.gpx"); + final File gc31j2h = new File(tempDir, "gc31j2h.gpx"); copyResourceToFile(R.raw.gc31j2h, gc31j2h); - GPXImporter.ImportGpxFileThread importThread = new GPXImporter.ImportGpxFileThread(gc31j2h, listId, importStepHandler, progressHandler); + final GPXImporter.ImportGpxFileThread importThread = new GPXImporter.ImportGpxFileThread(gc31j2h, listId, importStepHandler, progressHandler); runImportThread(importThread); assertEquals(4, importStepHandler.messages.size()); - Iterator<Message> iMsg = importStepHandler.messages.iterator(); + final Iterator<Message> iMsg = importStepHandler.messages.iterator(); assertEquals(GPXImporter.IMPORT_STEP_START, iMsg.next().what); assertEquals(GPXImporter.IMPORT_STEP_READ_FILE, iMsg.next().what); assertEquals(GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, iMsg.next().what); assertEquals(GPXImporter.IMPORT_STEP_FINISHED, iMsg.next().what); - SearchResult search = (SearchResult) importStepHandler.messages.get(3).obj; + final 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); + final Geocache cache = cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); assertTrue(cache.getWaypoints().isEmpty()); @@ -89,18 +88,17 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { } public void testImportGpxWithWaypoints() throws IOException { - File gc31j2h = new File(tempDir, "gc31j2h.gpx"); + final File gc31j2h = new File(tempDir, "gc31j2h.gpx"); copyResourceToFile(R.raw.gc31j2h, gc31j2h); copyResourceToFile(R.raw.gc31j2h_wpts, new File(tempDir, "gc31j2h-wpts.gpx")); - GPXImporter.ImportGpxFileThread importThread = new GPXImporter.ImportGpxFileThread(gc31j2h, listId, importStepHandler, progressHandler); + final GPXImporter.ImportGpxFileThread importThread = new GPXImporter.ImportGpxFileThread(gc31j2h, listId, importStepHandler, progressHandler); runImportThread(importThread); 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; + final 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); + final Geocache 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 Geocache cache = cgData.loadCache("AID1", LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); assertEquals("First Aid Station #1", cache.getName()); } @@ -127,42 +124,41 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { } public void testImportLoc() throws IOException { - File oc5952 = new File(tempDir, "oc5952.loc"); + final File oc5952 = new File(tempDir, "oc5952.loc"); copyResourceToFile(R.raw.oc5952_loc, oc5952); - GPXImporter.ImportLocFileThread importThread = new GPXImporter.ImportLocFileThread(oc5952, listId, importStepHandler, progressHandler); + final GPXImporter.ImportLocFileThread importThread = new GPXImporter.ImportLocFileThread(oc5952, listId, importStepHandler, progressHandler); runImportThread(importThread); 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; + final 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); + final Geocache cache = cgData.loadCache("OC5952", LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); } - private static void assertCacheProperties(cgCache cache) { + private static void assertCacheProperties(Geocache cache) { assertNotNull(cache); assertFalse(cache.getLocation().startsWith(",")); assertTrue(cache.isReliableLatLon()); } public void testImportGpxError() throws IOException { - File gc31j2h = new File(tempDir, "gc31j2h.gpx"); + final File gc31j2h = new File(tempDir, "gc31j2h.gpx"); copyResourceToFile(R.raw.gc31j2h_err, gc31j2h); - GPXImporter.ImportGpxFileThread importThread = new GPXImporter.ImportGpxFileThread(gc31j2h, listId, importStepHandler, progressHandler); + final GPXImporter.ImportGpxFileThread importThread = new GPXImporter.ImportGpxFileThread(gc31j2h, listId, importStepHandler, progressHandler); runImportThread(importThread); assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_FINISHED_WITH_ERROR); } public void testImportGpxCancel() throws IOException { - File gc31j2h = new File(tempDir, "gc31j2h.gpx"); + final File gc31j2h = new File(tempDir, "gc31j2h.gpx"); copyResourceToFile(R.raw.gc31j2h, gc31j2h); progressHandler.cancel(); - GPXImporter.ImportGpxFileThread importThread = new GPXImporter.ImportGpxFileThread(gc31j2h, listId, importStepHandler, progressHandler); + final GPXImporter.ImportGpxFileThread importThread = new GPXImporter.ImportGpxFileThread(gc31j2h, listId, importStepHandler, progressHandler); runImportThread(importThread); assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_CANCELED); @@ -171,16 +167,15 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { public void testImportGpxAttachment() { final String geocode = "GC31J2H"; removeCacheCompletely(geocode); - Uri uri = Uri.parse("android.resource://cgeo.geocaching.test/raw/gc31j2h"); + final Uri uri = Uri.parse("android.resource://cgeo.geocaching.test/raw/gc31j2h"); - GPXImporter.ImportGpxAttachmentThread importThread = new GPXImporter.ImportGpxAttachmentThread(uri, getInstrumentation().getContext().getContentResolver(), listId, importStepHandler, progressHandler); + final GPXImporter.ImportGpxAttachmentThread importThread = new GPXImporter.ImportGpxAttachmentThread(uri, getInstrumentation().getContext().getContentResolver(), listId, importStepHandler, progressHandler); runImportThread(importThread); 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; + final 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); + final Geocache cache = cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); assertTrue(cache.getWaypoints().isEmpty()); @@ -189,26 +184,25 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { public void testImportGpxZip() throws IOException { final String geocode = "GC31J2H"; removeCacheCompletely(geocode); - File pq7545915 = new File(tempDir, "7545915.zip"); + final File pq7545915 = new File(tempDir, "7545915.zip"); copyResourceToFile(R.raw.pq7545915, pq7545915); - GPXImporter.ImportGpxZipFileThread importThread = new GPXImporter.ImportGpxZipFileThread(pq7545915, listId, importStepHandler, progressHandler); + final GPXImporter.ImportGpxZipFileThread importThread = new GPXImporter.ImportGpxZipFileThread(pq7545915, listId, importStepHandler, progressHandler); runImportThread(importThread); 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; + final 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); + final Geocache 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 } public void testImportGpxZipErr() throws IOException { - File pqError = new File(tempDir, "pq_error.zip"); + final File pqError = new File(tempDir, "pq_error.zip"); copyResourceToFile(R.raw.pq_error, pqError); - GPXImporter.ImportGpxZipFileThread importThread = new GPXImporter.ImportGpxZipFileThread(pqError, listId, importStepHandler, progressHandler); + final GPXImporter.ImportGpxZipFileThread importThread = new GPXImporter.ImportGpxZipFileThread(pqError, listId, importStepHandler, progressHandler); runImportThread(importThread); assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_FINISHED_WITH_ERROR); @@ -217,16 +211,15 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { public void testImportGpxZipAttachment() { final String geocode = "GC31J2H"; removeCacheCompletely(geocode); - Uri uri = Uri.parse("android.resource://cgeo.geocaching.test/raw/pq7545915"); + final Uri uri = Uri.parse("android.resource://cgeo.geocaching.test/raw/pq7545915"); - GPXImporter.ImportGpxZipAttachmentThread importThread = new GPXImporter.ImportGpxZipAttachmentThread(uri, getInstrumentation().getContext().getContentResolver(), listId, importStepHandler, progressHandler); + final GPXImporter.ImportGpxZipAttachmentThread importThread = new GPXImporter.ImportGpxZipAttachmentThread(uri, getInstrumentation().getContext().getContentResolver(), listId, importStepHandler, progressHandler); runImportThread(importThread); 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; + final 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); + final Geocache 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(false, null, CacheType.ALL, listId); - List<cgCache> cachesInList = new ArrayList<cgCache>(); + final SearchResult search = cgData.getBatchOfStoredCaches(null, CacheType.ALL, listId); + final List<Geocache> cachesInList = new ArrayList<Geocache>(); 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 c195953..f6c0b99 100644 --- a/tests/src/cgeo/geocaching/files/GPXParserTest.java +++ b/tests/src/cgeo/geocaching/files/GPXParserTest.java @@ -1,11 +1,11 @@ package cgeo.geocaching.files; +import cgeo.geocaching.Geocache; import cgeo.geocaching.LogEntry; import cgeo.geocaching.SearchResult; import cgeo.geocaching.StoredList; -import cgeo.geocaching.cgCache; -import cgeo.geocaching.cgWaypoint; -import cgeo.geocaching.cgeoapplication; +import cgeo.geocaching.Waypoint; +import cgeo.geocaching.cgData; import cgeo.geocaching.enumerations.CacheSize; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.enumerations.LoadFlags; @@ -24,21 +24,22 @@ import java.util.Collection; import java.util.EnumSet; import java.util.HashSet; import java.util.List; +import java.util.Locale; import java.util.Set; public class GPXParserTest extends AbstractResourceInstrumentationTestCase { - private static final SimpleDateFormat LOG_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'"); // 2010-04-20T07:00:00Z + private static final SimpleDateFormat LOG_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US); // 2010-04-20T07:00:00Z private int listId; public void testGPXVersion100() throws Exception { testGPXVersion(R.raw.gc1bkp3_gpx100); } - private cgCache testGPXVersion(final int resourceId) throws IOException, ParserException { - final List<cgCache> caches = readGPX10(resourceId); + private Geocache testGPXVersion(final int resourceId) throws IOException, ParserException { + final List<Geocache> caches = readGPX10(resourceId); assertNotNull(caches); assertEquals(1, caches.size()); - final cgCache cache = caches.get(0); + final Geocache cache = caches.get(0); assertEquals("GC1BKP3", cache.getGeocode()); assertEquals("9946f030-a514-46d8-a050-a60e92fd2e1a", cache.getGuid()); assertEquals(CacheType.TRADITIONAL, cache.getType()); @@ -51,20 +52,20 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { assertEquals(1.0f, cache.getDifficulty()); assertEquals(5.0f, cache.getTerrain()); assertEquals("Baden-Württemberg, Germany", cache.getLocation()); - assertEquals("Ein alter Kindheitstraum, ein Schatz auf einer unbewohnten Insel.\nA old dream of my childhood, a treasure on a lonely island.", cache.getShortdesc()); + assertEquals("Ein alter Kindheitstraum, ein Schatz auf einer unbewohnten Insel.\nA old dream of my childhood, a treasure on a lonely island.", cache.getShortDescription()); assertEquals(new Geopoint(48.859683, 9.1874), cache.getCoords()); return cache; } public void testGPXVersion101() throws IOException, ParserException { - final cgCache cache = testGPXVersion(R.raw.gc1bkp3_gpx101); + final Geocache cache = testGPXVersion(R.raw.gc1bkp3_gpx101); assertNotNull(cache.getAttributes()); assertEquals(10, cache.getAttributes().size()); } public void testOC() throws IOException, ParserException { - final List<cgCache> caches = readGPX10(R.raw.oc5952_gpx); - final cgCache cache = caches.get(0); + final List<Geocache> caches = readGPX10(R.raw.oc5952_gpx); + final Geocache cache = caches.get(0); assertEquals("OC5952", cache.getGeocode()); assertEquals(CacheType.TRADITIONAL, cache.getType()); assertEquals(false, cache.isArchived()); @@ -76,16 +77,16 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { assertEquals(1.0f, cache.getDifficulty()); assertEquals(4.0f, cache.getTerrain()); assertEquals("Baden-Württemberg, Germany", cache.getLocation()); - assertEquals("Ein alter Kindheitstraum, ein Schatz auf einer unbewohnten Insel. A old dream of my childhood, a treasure on a lonely is", cache.getShortdesc()); + assertEquals("Ein alter Kindheitstraum, ein Schatz auf einer unbewohnten Insel. A old dream of my childhood, a treasure on a lonely is", cache.getShortDescription()); assertEquals(new Geopoint(48.85968, 9.18740), cache.getCoords()); assertTrue(cache.isReliableLatLon()); } public void testGc31j2h() throws IOException, ParserException { removeCacheCompletely("GC31J2H"); - final List<cgCache> caches = readGPX10(R.raw.gc31j2h); + final List<Geocache> caches = readGPX10(R.raw.gc31j2h); assertEquals(1, caches.size()); - final cgCache cache = caches.get(0); + final Geocache cache = caches.get(0); assertGc31j2h(cache); assertSame(cache, caches.get(0)); @@ -97,15 +98,15 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { public void testGc31j2hWpts() throws IOException, ParserException { removeCacheCompletely("GC31J2H"); - List<cgCache> caches = readGPX10(R.raw.gc31j2h, R.raw.gc31j2h_wpts); + final List<Geocache> caches = readGPX10(R.raw.gc31j2h, R.raw.gc31j2h_wpts); assertEquals(1, caches.size()); - cgCache cache = caches.get(0); + final Geocache cache = caches.get(0); assertGc31j2h(cache); assertGc31j2hWaypoints(cache); } public void testGc31j2hWptsWithoutCache() throws IOException, ParserException { - final List<cgCache> caches = readGPX10(R.raw.gc31j2h_wpts); + final List<Geocache> caches = readGPX10(R.raw.gc31j2h_wpts); assertEquals(0, caches.size()); } @@ -122,7 +123,7 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { assertEquals(WaypointType.PARKING, GPXParser.convertWaypointSym2Type(WaypointType.PARKING.getL10n())); } - private static void assertGc31j2h(final cgCache cache) { + private static void assertGc31j2h(final Geocache cache) { assertEquals("GC31J2H", cache.getGeocode()); assertEquals("Hockenheimer City-Brunnen", cache.getName()); assertTrue("Hockenheimer City-Brunnen by vptsz, Multi-cache (2/1)", cache.getShortDescription().startsWith("Kurzer informativer Multi entlang der Brunnen")); @@ -140,7 +141,7 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { assertFalse(cache.isDisabled()); assertFalse(cache.isEventCache()); assertFalse(cache.isPremiumMembersOnly()); - assertFalse(cache.isOwn()); + assertFalse(cache.isOwner()); assertTrue(cache.isFound()); assertEquals("Station3: Der zerbrochene Stein zählt doppelt.\nFinal: Oben neben dem Tor", cache.getHint()); // logs @@ -163,10 +164,10 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { } } - private static void assertGc31j2hWaypoints(final cgCache cache) { + private static void assertGc31j2hWaypoints(final Geocache cache) { assertNotNull(cache.getWaypoints()); assertEquals(2, cache.getWaypoints().size()); - cgWaypoint wp = cache.getWaypoints().get(0); + Waypoint wp = cache.getWaypoints().get(0); assertEquals("GC31J2H", wp.getGeocode()); assertEquals("00", wp.getPrefix()); assertEquals("---", wp.getLookup()); @@ -187,24 +188,24 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { assertEquals(8.545100, wp.getCoords().getLongitude(), 0.000001); } - private List<cgCache> readGPX10(int... resourceIds) throws IOException, ParserException { + private List<Geocache> readGPX10(int... resourceIds) throws IOException, ParserException { final GPX10Parser parser = new GPX10Parser(listId); return readVersionedGPX(parser, resourceIds); } - private List<cgCache> readGPX11(int... resourceIds) throws IOException, ParserException { + private List<Geocache> readGPX11(int... resourceIds) throws IOException, ParserException { final GPX11Parser parser = new GPX11Parser(listId); return readVersionedGPX(parser, resourceIds); } - private List<cgCache> readVersionedGPX(final GPXParser parser, int... resourceIds) throws IOException, ParserException { + private List<Geocache> readVersionedGPX(final GPXParser parser, int... resourceIds) throws IOException, ParserException { final Set<String> result = new HashSet<String>(); for (int resourceId : resourceIds) { final InputStream instream = getResourceStream(resourceId); try { - Collection<cgCache> caches = parser.parse(instream, null); + Collection<Geocache> caches = parser.parse(instream, null); assertNotNull(caches); - for (cgCache cache : caches) { + for (Geocache cache : caches) { result.add(cache.getGeocode()); } } finally { @@ -212,47 +213,37 @@ 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<Geocache>(cgData.loadCaches(result, LoadFlags.LOAD_ALL_DB_ONLY)); } - public static void testParseDateWithFractionalSeconds() { + public static void testParseDateWithFractionalSeconds() throws ParseException { // was experienced in GSAK file final String dateString = "2011-08-13T02:52:18.103Z"; - try { - GPXParser.parseDate(dateString); - } catch (ParseException e) { - fail(); - e.printStackTrace(); - } + GPXParser.parseDate(dateString); } - public static void testParseDateWithHugeFraction() { + public static void testParseDateWithHugeFraction() throws ParseException { // see issue 821 - String dateString = "2011-11-07T00:00:00.0000000-07:00"; - try { - GPXParser.parseDate(dateString); - } catch (ParseException e) { - fail(); - e.printStackTrace(); - } + final String dateString = "2011-11-07T00:00:00.0000000-07:00"; + GPXParser.parseDate(dateString); } public void testSelfmadeGPXWithoutGeocodes() throws Exception { - final List<cgCache> caches = readGPX11(R.raw.no_connector); + final List<Geocache> caches = readGPX11(R.raw.no_connector); assertEquals(13, caches.size()); } public void testTexasChallenge2012() throws Exception { - final List<cgCache> caches = readGPX10(R.raw.challenge); + final List<Geocache> caches = readGPX10(R.raw.challenge); // previously these caches overwrote each other during parsing assertEquals(130, caches.size()); } public void testGeoToad() throws Exception { - final List<cgCache> caches = readGPX10(R.raw.geotoad); + final List<Geocache> caches = readGPX10(R.raw.geotoad); assertEquals(2, caches.size()); - List<String> codes = new ArrayList<String>(); - for (cgCache cache : caches) { + final List<String> codes = new ArrayList<String>(); + for (Geocache cache : caches) { codes.add(cache.getGeocode()); } assertTrue(codes.contains("GC2KN6K")); @@ -263,12 +254,11 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { // this test should be in CacheTest, but it is easier to create here due to the GPX import abilities final String geocode = "GC31J2H"; removeCacheCompletely(geocode); - final List<cgCache> caches = readGPX10(R.raw.lazy); + final List<Geocache> 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 Geocache minimalCache = cgData.loadCache(geocode, EnumSet.of(LoadFlag.LOAD_DB_MINIMAL)); // now check that we load lazy members on demand assertFalse(minimalCache.getAttributes().isEmpty()); @@ -282,7 +272,7 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { removeCacheCompletely(geocode); // first import - List<cgCache> caches = readGPX10(R.raw.lazy); + List<Geocache> caches = readGPX10(R.raw.lazy); assertEquals(1, caches.size()); assertEquals(6, caches.get(0).getLogs().size()); @@ -297,17 +287,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(false, null, CacheType.ALL, listId); + final 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/files/LocParserTest.java b/tests/src/cgeo/geocaching/files/LocParserTest.java index 5170577..c95d860 100644 --- a/tests/src/cgeo/geocaching/files/LocParserTest.java +++ b/tests/src/cgeo/geocaching/files/LocParserTest.java @@ -1,6 +1,6 @@ package cgeo.geocaching.files; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.enumerations.CacheSize; import cgeo.geocaching.geopoint.Geopoint; import cgeo.geocaching.test.AbstractResourceInstrumentationTestCase; @@ -13,9 +13,9 @@ import java.util.Collection; import java.util.List; public class LocParserTest extends AbstractResourceInstrumentationTestCase { - private List<cgCache> readLoc(int resourceId) throws IOException, ParserException { + private List<Geocache> readLoc(int resourceId) throws IOException, ParserException { final LocParser parser = new LocParser(1); - Collection<cgCache> caches = null; + Collection<Geocache> caches = null; final InputStream instream = getResourceStream(resourceId); try { caches = parser.parse(instream, null); @@ -25,13 +25,13 @@ public class LocParserTest extends AbstractResourceInstrumentationTestCase { instream.close(); } - return new ArrayList<cgCache>(caches); + return new ArrayList<Geocache>(caches); } public void testOCLoc() throws IOException, ParserException { - final List<cgCache> caches = readLoc(R.raw.oc5952_loc); + final List<Geocache> caches = readLoc(R.raw.oc5952_loc); assertEquals(1, caches.size()); - final cgCache cache = caches.get(0); + final Geocache cache = caches.get(0); assertNotNull(cache); assertEquals("OC5952", cache.getGeocode()); assertEquals("Die Schatzinsel / treasure island", cache.getName()); @@ -39,9 +39,9 @@ public class LocParserTest extends AbstractResourceInstrumentationTestCase { } public void testGCLoc() throws IOException, ParserException { - final List<cgCache> caches = readLoc(R.raw.gc1bkp3_loc); + final List<Geocache> caches = readLoc(R.raw.gc1bkp3_loc); assertEquals(1, caches.size()); - final cgCache cache = caches.get(0); + final Geocache cache = caches.get(0); assertNotNull(cache); assertEquals("GC1BKP3", cache.getGeocode()); assertEquals("Die Schatzinsel / treasure island", cache.getName()); diff --git a/tests/src/cgeo/geocaching/files/SimpleDirChooserUITest.java b/tests/src/cgeo/geocaching/files/SimpleDirChooserUITest.java new file mode 100644 index 0000000..2578efa --- /dev/null +++ b/tests/src/cgeo/geocaching/files/SimpleDirChooserUITest.java @@ -0,0 +1,84 @@ +package cgeo.geocaching.files; + +import com.jayway.android.robotium.solo.Solo; + +import android.annotation.TargetApi; +import android.os.Build; +import android.test.ActivityInstrumentationTestCase2; +import android.test.suitebuilder.annotation.Suppress; +import android.widget.CheckBox; + +import java.util.ArrayList; + +@TargetApi(Build.VERSION_CODES.FROYO) +@Suppress() /* This test breaks the continuous integration server, do not run it for now. */ +public class SimpleDirChooserUITest extends ActivityInstrumentationTestCase2<SimpleDirChooser> { + + private Solo solo; + + public SimpleDirChooserUITest() { + super(SimpleDirChooser.class); + } + + @Override + public void setUp() throws Exception { + super.setUp(); + solo = new Solo(getInstrumentation(), getActivity()); + } + + public void testSingleSelection() throws InterruptedException { + // normally our activity should be ready, but we already had Jenkins report no checkboxes right here at the beginning + solo.waitForActivity(solo.getCurrentActivity().getClass().getSimpleName(), 2000); + + assertChecked("Newly opened activity", 0); + solo.scrollToBottom(); + pause(); + // according to the documentation, automatic pauses only happen in the clickXYZ() methods. + // Therefore lets introduce a manual pause after the scrolling methods. + + final int lastIndex = solo.getCurrentCheckBoxes().size() - 1; + + solo.clickOnCheckBox(lastIndex); + assertTrue(solo.getCurrentCheckBoxes().get(lastIndex).isChecked()); + assertFalse(solo.getCurrentCheckBoxes().get(0).isChecked()); + assertChecked("Clicked last checkbox", 1); + + solo.scrollUp(); + pause(); + solo.scrollToBottom(); + pause(); + assertChecked("Refreshing last checkbox", 1); + + solo.scrollToTop(); + pause(); + solo.clickOnCheckBox(0); + assertChecked("Clicked first checkbox", 1); + assertTrue(solo.getCurrentCheckBoxes().get(0).isChecked()); + solo.clickOnCheckBox(1); + assertChecked("Clicked second checkbox", 1); + assertTrue(solo.getCurrentCheckBoxes().get(1).isChecked()); + } + + private static void pause() throws InterruptedException { + Thread.sleep(500); + } + + private void assertChecked(String message, int expectedChecked) { + int checked = 0; + final ArrayList<CheckBox> boxes = solo.getCurrentCheckBoxes(); + assertNotNull("Could not get checkboxes", boxes); + assertTrue("There are no checkboxes", boxes.size() > 1); + for (CheckBox checkBox : boxes) { + if (checkBox.isChecked()) { + checked++; + } + } + assertEquals(message, expectedChecked, checked); + } + + @Override + public void tearDown() throws Exception { + solo.finishOpenedActivities(); + super.tearDown(); + } +} diff --git a/tests/src/cgeo/geocaching/filter/DifficultyFilterTest.java b/tests/src/cgeo/geocaching/filter/DifficultyFilterTest.java index a24cf72..b3ff056 100644 --- a/tests/src/cgeo/geocaching/filter/DifficultyFilterTest.java +++ b/tests/src/cgeo/geocaching/filter/DifficultyFilterTest.java @@ -1,15 +1,15 @@ package cgeo.geocaching.filter; import cgeo.CGeoTestCase; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; public class DifficultyFilterTest extends CGeoTestCase { public static void testTerrainFilter() { - final cgCache easy = new cgCache(); + final Geocache easy = new Geocache(); easy.setDifficulty(1.5f); - final cgCache hard = new cgCache(); + final Geocache hard = new Geocache(); hard.setDifficulty(5f); final DifficultyFilter easyFilter = new DifficultyFilter(1); diff --git a/tests/src/cgeo/geocaching/filter/SizeFilterTest.java b/tests/src/cgeo/geocaching/filter/SizeFilterTest.java index a641874..2c6552b 100644 --- a/tests/src/cgeo/geocaching/filter/SizeFilterTest.java +++ b/tests/src/cgeo/geocaching/filter/SizeFilterTest.java @@ -1,15 +1,15 @@ package cgeo.geocaching.filter; import cgeo.CGeoTestCase; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.enumerations.CacheSize; import java.util.ArrayList; public class SizeFilterTest extends CGeoTestCase { - private cgCache micro; - private cgCache regular; + private Geocache micro; + private Geocache regular; private SizeFilter microFilter; @Override @@ -17,10 +17,10 @@ public class SizeFilterTest extends CGeoTestCase { super.setUp(); // cache initialization can only be done without errors after application setup - micro = new cgCache(); + micro = new Geocache(); micro.setSize(CacheSize.MICRO); - regular = new cgCache(); + regular = new Geocache(); regular.setSize(CacheSize.REGULAR); microFilter = new SizeFilter(CacheSize.MICRO); @@ -37,7 +37,7 @@ public class SizeFilterTest extends CGeoTestCase { } public void testFilter() { - final ArrayList<cgCache> list = new ArrayList<cgCache>(); + final ArrayList<Geocache> list = new ArrayList<Geocache>(); list.add(regular); list.add(micro); assertEquals(2, list.size()); diff --git a/tests/src/cgeo/geocaching/filter/StateArchivedFilterTest.java b/tests/src/cgeo/geocaching/filter/StateArchivedFilterTest.java index 9b40140..2d7f2d2 100644 --- a/tests/src/cgeo/geocaching/filter/StateArchivedFilterTest.java +++ b/tests/src/cgeo/geocaching/filter/StateArchivedFilterTest.java @@ -1,13 +1,13 @@ package cgeo.geocaching.filter; import cgeo.CGeoTestCase; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.filter.StateFilter.StateArchivedFilter; public class StateArchivedFilterTest extends CGeoTestCase { private StateFilter.StateArchivedFilter archivedFilter; - private cgCache archivedCache; + private Geocache archivedCache; @Override protected void setUp() throws Exception { @@ -15,13 +15,13 @@ public class StateArchivedFilterTest extends CGeoTestCase { // members can only be setup here, after application is initialized archivedFilter = new StateArchivedFilter(); - archivedCache = new cgCache(); + archivedCache = new Geocache(); archivedCache.setArchived(true); } public void testAccepts() { assertTrue(archivedFilter.accepts(archivedCache)); - assertFalse(archivedFilter.accepts(new cgCache())); + assertFalse(archivedFilter.accepts(new Geocache())); } } diff --git a/tests/src/cgeo/geocaching/filter/StateDisabledFilterTest.java b/tests/src/cgeo/geocaching/filter/StateDisabledFilterTest.java index e73f771..6d50beb 100644 --- a/tests/src/cgeo/geocaching/filter/StateDisabledFilterTest.java +++ b/tests/src/cgeo/geocaching/filter/StateDisabledFilterTest.java @@ -1,26 +1,26 @@ package cgeo.geocaching.filter; import cgeo.CGeoTestCase; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.filter.StateFilter.StateDisabledFilter; public class StateDisabledFilterTest extends CGeoTestCase { private StateFilter.StateDisabledFilter disabledFilter; - private cgCache disabledCache; + private Geocache disabledCache; @Override protected void setUp() throws Exception { super.setUp(); disabledFilter = new StateDisabledFilter(); - disabledCache = new cgCache(); + disabledCache = new Geocache(); disabledCache.setDisabled(true); } public void testAccepts() { assertTrue(disabledFilter.accepts(disabledCache)); - assertFalse(disabledFilter.accepts(new cgCache())); + assertFalse(disabledFilter.accepts(new Geocache())); } } diff --git a/tests/src/cgeo/geocaching/filter/StateFoundFilterTest.java b/tests/src/cgeo/geocaching/filter/StateFoundFilterTest.java index 053363f..c02794c 100644 --- a/tests/src/cgeo/geocaching/filter/StateFoundFilterTest.java +++ b/tests/src/cgeo/geocaching/filter/StateFoundFilterTest.java @@ -1,26 +1,26 @@ package cgeo.geocaching.filter; import cgeo.CGeoTestCase; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.filter.StateFilter.StateFoundFilter; public class StateFoundFilterTest extends CGeoTestCase { private StateFilter.StateFoundFilter foundFilter; - private cgCache foundCache; + private Geocache foundCache; @Override protected void setUp() throws Exception { super.setUp(); foundFilter = new StateFoundFilter(); - foundCache = new cgCache(); + foundCache = new Geocache(); foundCache.setFound(true); } public void testAccepts() { assertTrue(foundFilter.accepts(foundCache)); - assertFalse(foundFilter.accepts(new cgCache())); + assertFalse(foundFilter.accepts(new Geocache())); } } diff --git a/tests/src/cgeo/geocaching/filter/StateNonPremiumFilterTest.java b/tests/src/cgeo/geocaching/filter/StateNonPremiumFilterTest.java index 98d9e63..3c36c0d 100644 --- a/tests/src/cgeo/geocaching/filter/StateNonPremiumFilterTest.java +++ b/tests/src/cgeo/geocaching/filter/StateNonPremiumFilterTest.java @@ -1,26 +1,26 @@ package cgeo.geocaching.filter; import cgeo.CGeoTestCase; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.filter.StateFilter.StateNonPremiumFilter; public class StateNonPremiumFilterTest extends CGeoTestCase { private StateFilter.StateNonPremiumFilter nonPremiumFilter; - private cgCache premiumCache; + private Geocache premiumCache; @Override protected void setUp() throws Exception { super.setUp(); nonPremiumFilter = new StateNonPremiumFilter(); - premiumCache = new cgCache(); + premiumCache = new Geocache(); premiumCache.setPremiumMembersOnly(true); } public void testAccepts() { assertFalse(nonPremiumFilter.accepts(premiumCache)); - assertTrue(nonPremiumFilter.accepts(new cgCache())); + assertTrue(nonPremiumFilter.accepts(new Geocache())); } } diff --git a/tests/src/cgeo/geocaching/filter/StatePremiumFilterTest.java b/tests/src/cgeo/geocaching/filter/StatePremiumFilterTest.java index 9221da0..744ebb9 100644 --- a/tests/src/cgeo/geocaching/filter/StatePremiumFilterTest.java +++ b/tests/src/cgeo/geocaching/filter/StatePremiumFilterTest.java @@ -1,26 +1,26 @@ package cgeo.geocaching.filter; import cgeo.CGeoTestCase; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.filter.StateFilter.StatePremiumFilter; public class StatePremiumFilterTest extends CGeoTestCase { private StateFilter.StatePremiumFilter premiumFilter; - private cgCache premiumCache; + private Geocache premiumCache; @Override protected void setUp() throws Exception { super.setUp(); premiumFilter = new StatePremiumFilter(); - premiumCache = new cgCache(); + premiumCache = new Geocache(); premiumCache.setPremiumMembersOnly(true); } public void testAccepts() { assertTrue(premiumFilter.accepts(premiumCache)); - assertFalse(premiumFilter.accepts(new cgCache())); + assertFalse(premiumFilter.accepts(new Geocache())); } } diff --git a/tests/src/cgeo/geocaching/filter/TerrainFilterTest.java b/tests/src/cgeo/geocaching/filter/TerrainFilterTest.java index 9deea34..d64f4d9 100644 --- a/tests/src/cgeo/geocaching/filter/TerrainFilterTest.java +++ b/tests/src/cgeo/geocaching/filter/TerrainFilterTest.java @@ -1,15 +1,15 @@ package cgeo.geocaching.filter; import cgeo.CGeoTestCase; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; public class TerrainFilterTest extends CGeoTestCase { public static void testTerrainFilter() { - final cgCache easy = new cgCache(); + final Geocache easy = new Geocache(); easy.setTerrain(1.5f); - final cgCache hard = new cgCache(); + final Geocache hard = new Geocache(); hard.setTerrain(5f); final AbstractRangeFilter easyFilter = new TerrainFilter(1); diff --git a/tests/src/cgeo/geocaching/filter/TypeFilterTest.java b/tests/src/cgeo/geocaching/filter/TypeFilterTest.java index 5b2631c..3a43b33 100644 --- a/tests/src/cgeo/geocaching/filter/TypeFilterTest.java +++ b/tests/src/cgeo/geocaching/filter/TypeFilterTest.java @@ -1,7 +1,7 @@ package cgeo.geocaching.filter; import cgeo.CGeoTestCase; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.enumerations.CacheType; import java.util.ArrayList; @@ -9,18 +9,18 @@ import java.util.ArrayList; public class TypeFilterTest extends CGeoTestCase { private TypeFilter traditionalFilter; - private cgCache traditional; - private cgCache mystery; + private Geocache traditional; + private Geocache mystery; @Override protected void setUp() throws Exception { super.setUp(); traditionalFilter = new TypeFilter(CacheType.TRADITIONAL); - traditional = new cgCache(); + traditional = new Geocache(); traditional.setType(CacheType.TRADITIONAL); - mystery = new cgCache(); + mystery = new Geocache(); mystery.setType(CacheType.MYSTERY); } @@ -30,7 +30,7 @@ public class TypeFilterTest extends CGeoTestCase { } public void testFilter() { - final ArrayList<cgCache> list = new ArrayList<cgCache>(); + final ArrayList<Geocache> list = new ArrayList<Geocache>(); traditionalFilter.filter(list); assertEquals(0, list.size()); diff --git a/tests/src/cgeo/geocaching/geopoint/GeoPointFormatterTest.java b/tests/src/cgeo/geocaching/geopoint/GeoPointFormatterTest.java index 76c0f09..c0cea01 100644 --- a/tests/src/cgeo/geocaching/geopoint/GeoPointFormatterTest.java +++ b/tests/src/cgeo/geocaching/geopoint/GeoPointFormatterTest.java @@ -8,7 +8,7 @@ public class GeoPointFormatterTest extends AndroidTestCase { public static void testFormat() { // taken from GC30R6G - Geopoint point = new Geopoint("N 51° 21.104 E 010° 15.369"); + final Geopoint point = new Geopoint("N 51° 21.104 E 010° 15.369"); final String format = GeopointFormatter.format(GeopointFormatter.Format.LAT_LON_DECDEGREE_COMMA, point); assertEquals(format, "51.351733,10.256150", format); final String formatMinute = GeopointFormatter.format(GeopointFormatter.Format.LAT_LON_DECMINUTE_RAW, point); diff --git a/tests/src/cgeo/geocaching/geopoint/GeoPointParserTest.java b/tests/src/cgeo/geocaching/geopoint/GeoPointParserTest.java index 44fbe18..6b70523 100644 --- a/tests/src/cgeo/geocaching/geopoint/GeoPointParserTest.java +++ b/tests/src/cgeo/geocaching/geopoint/GeoPointParserTest.java @@ -28,7 +28,7 @@ public class GeoPointParserTest extends AndroidTestCase { } catch (Geopoint.ParseException e) { // expected } - assertEquals(null, point); + assertNull(point); } @@ -55,7 +55,7 @@ public class GeoPointParserTest extends AndroidTestCase { final Geopoint p2 = GeopointParser.parse("N51 21.523", "E07 02.680"); assertNotNull(p1); assertNotNull(p2); - assertTrue(p1.equals(p2)); + assertEquals(p1, p2); } public static void testUnrelatedParts() { @@ -65,7 +65,7 @@ public class GeoPointParserTest extends AndroidTestCase { } catch (Geopoint.ParseException e) { // expected } - assertEquals(null, point); + assertNull(point); } public static void testComma() { @@ -75,6 +75,15 @@ public class GeoPointParserTest extends AndroidTestCase { "E 15° 53' 41.68''"); assertNotNull(pointComma); assertNotNull(pointDot); - assertTrue(pointComma.equals(pointDot)); + assertEquals(pointComma, pointDot); } + + public static void testBlankAddedByAutocorrectionDot() { + assertEquals(refLatitude, GeopointParser.parseLatitude("N 49° 56. 031"), 1e-8); + } + + public static void testBlankAddedByAutocorrectionComma() { + assertEquals(refLatitude, GeopointParser.parseLatitude("N 49° 56, 031"), 1e-8); + } + } diff --git a/tests/src/cgeo/geocaching/geopoint/GeopointTest.java b/tests/src/cgeo/geocaching/geopoint/GeopointTest.java index 1401cb6..8aaeef8 100644 --- a/tests/src/cgeo/geocaching/geopoint/GeopointTest.java +++ b/tests/src/cgeo/geocaching/geopoint/GeopointTest.java @@ -72,7 +72,7 @@ public class GeopointTest extends AndroidTestCase { checkDDD(gp1, 'N', 51, 30000, 'E', 13, 80000); - Geopoint gp1a = new Geopoint(String.valueOf(gp1.getLatDir()), String.valueOf(gp1.getLatDeg()), String.valueOf(gp1.getLatDegFrac()), + final Geopoint gp1a = new Geopoint(String.valueOf(gp1.getLatDir()), String.valueOf(gp1.getLatDeg()), String.valueOf(gp1.getLatDegFrac()), String.valueOf(gp1.getLonDir()), String.valueOf(gp1.getLonDeg()), String.valueOf(gp1.getLonDegFrac())); Assert.assertTrue(gp1a.equals(gp1)); @@ -82,7 +82,7 @@ public class GeopointTest extends AndroidTestCase { checkDDD(gp2, 'N', 51, 34567, 'E', 13, 87654); - Geopoint gp2a = new Geopoint(String.valueOf(gp2.getLatDir()), String.valueOf(gp2.getLatDeg()), String.valueOf(gp2.getLatDegFrac()), + final Geopoint gp2a = new Geopoint(String.valueOf(gp2.getLatDir()), String.valueOf(gp2.getLatDeg()), String.valueOf(gp2.getLatDegFrac()), String.valueOf(gp2.getLonDir()), String.valueOf(gp2.getLonDeg()), String.valueOf(gp2.getLonDegFrac())); Assert.assertTrue(gp2a.equals(gp2)); @@ -92,7 +92,7 @@ public class GeopointTest extends AndroidTestCase { checkDDD(gp3, 'N', 51, 30000, 'E', 13, 80000); - Geopoint gp3a = new Geopoint(String.valueOf(gp3.getLatDir()), String.valueOf(gp3.getLatDeg()), String.valueOf(gp3.getLatDegFrac()), + final Geopoint gp3a = new Geopoint(String.valueOf(gp3.getLatDir()), String.valueOf(gp3.getLatDeg()), String.valueOf(gp3.getLatDegFrac()), String.valueOf(gp3.getLonDir()), String.valueOf(gp3.getLonDeg()), String.valueOf(gp3.getLonDegFrac())); checkTolerance(gp3, gp3a, 5e-5); @@ -102,7 +102,7 @@ public class GeopointTest extends AndroidTestCase { checkDDD(gp4, 'N', 51, 12, 'E', 13, 89); - Geopoint gp4a = new Geopoint(String.valueOf(gp4.getLatDir()), String.valueOf(gp4.getLatDeg()), String.valueOf(gp4.getLatDegFrac()), + final Geopoint gp4a = new Geopoint(String.valueOf(gp4.getLatDir()), String.valueOf(gp4.getLatDeg()), String.valueOf(gp4.getLatDegFrac()), String.valueOf(gp4.getLonDir()), String.valueOf(gp4.getLonDeg()), String.valueOf(gp4.getLonDegFrac())); checkTolerance(gp4, gp4a, 5e-5); @@ -128,7 +128,7 @@ public class GeopointTest extends AndroidTestCase { checkDMM(gp1, 'N', 51, 18, 0, 'E', 13, 48, 0); - Geopoint gp1a = new Geopoint(String.valueOf(gp1.getLatDir()), String.valueOf(gp1.getLatDeg()), String.valueOf(gp1.getLatMin()), String.valueOf(gp1.getLatMinFrac()), + final Geopoint gp1a = new Geopoint(String.valueOf(gp1.getLatDir()), String.valueOf(gp1.getLatDeg()), String.valueOf(gp1.getLatMin()), String.valueOf(gp1.getLatMinFrac()), String.valueOf(gp1.getLonDir()), String.valueOf(gp1.getLonDeg()), String.valueOf(gp1.getLonMin()), String.valueOf(gp1.getLonMinFrac())); Assert.assertTrue(gp1a.equals(gp1)); @@ -138,7 +138,7 @@ public class GeopointTest extends AndroidTestCase { checkDMM(gp2, 'N', 51, 20, 740, 'E', 13, 52, 592); - Geopoint gp2a = new Geopoint(String.valueOf(gp2.getLatDir()), String.valueOf(gp2.getLatDeg()), String.valueOf(gp2.getLatMin()), String.valueOf(gp2.getLatMinFrac()), + final Geopoint gp2a = new Geopoint(String.valueOf(gp2.getLatDir()), String.valueOf(gp2.getLatDeg()), String.valueOf(gp2.getLatMin()), String.valueOf(gp2.getLatMinFrac()), String.valueOf(gp2.getLonDir()), String.valueOf(gp2.getLonDeg()), String.valueOf(gp2.getLonMin()), String.valueOf(gp2.getLonMinFrac())); checkTolerance(gp2, gp2a, 5e-5); @@ -148,7 +148,7 @@ public class GeopointTest extends AndroidTestCase { checkDMM(gp3, 'N', 51, 18, 0, 'E', 13, 48, 0); - Geopoint gp3a = new Geopoint(String.valueOf(gp3.getLatDir()), String.valueOf(gp3.getLatDeg()), String.valueOf(gp3.getLatMin()), String.valueOf(gp3.getLatMinFrac()), + final Geopoint gp3a = new Geopoint(String.valueOf(gp3.getLatDir()), String.valueOf(gp3.getLatDeg()), String.valueOf(gp3.getLatMin()), String.valueOf(gp3.getLatMinFrac()), String.valueOf(gp3.getLonDir()), String.valueOf(gp3.getLonDeg()), String.valueOf(gp3.getLonMin()), String.valueOf(gp3.getLonMinFrac())); checkTolerance(gp3, gp3a, 5e-5); @@ -158,7 +158,7 @@ public class GeopointTest extends AndroidTestCase { checkDMM(gp4, 'N', 51, 0, 7, 'E', 13, 0, 53); - Geopoint gp4a = new Geopoint(String.valueOf(gp4.getLatDir()), String.valueOf(gp4.getLatDeg()), String.valueOf(gp4.getLatMin()), String.valueOf(gp4.getLatMinFrac()), + final Geopoint gp4a = new Geopoint(String.valueOf(gp4.getLatDir()), String.valueOf(gp4.getLatDeg()), String.valueOf(gp4.getLatMin()), String.valueOf(gp4.getLatMinFrac()), String.valueOf(gp4.getLonDir()), String.valueOf(gp4.getLonDeg()), String.valueOf(gp4.getLonMin()), String.valueOf(gp4.getLonMinFrac())); checkTolerance(gp4, gp4a, 5e-5); @@ -181,7 +181,7 @@ public class GeopointTest extends AndroidTestCase { checkDMS(gp1, 'N', 51, 18, 0, 0, 'E', 13, 48, 0, 0); - Geopoint gp1a = new Geopoint(String.valueOf(gp1.getLatDir()), String.valueOf(gp1.getLatDeg()), String.valueOf(gp1.getLatMin()), String.valueOf(gp1.getLatSec()), String.valueOf(gp1.getLatSecFrac()), + final Geopoint gp1a = new Geopoint(String.valueOf(gp1.getLatDir()), String.valueOf(gp1.getLatDeg()), String.valueOf(gp1.getLatMin()), String.valueOf(gp1.getLatSec()), String.valueOf(gp1.getLatSecFrac()), String.valueOf(gp1.getLonDir()), String.valueOf(gp1.getLonDeg()), String.valueOf(gp1.getLonMin()), String.valueOf(gp1.getLonSec()), String.valueOf(gp1.getLonSecFrac())); Assert.assertTrue(gp1a.equals(gp1)); @@ -191,7 +191,7 @@ public class GeopointTest extends AndroidTestCase { checkDMS(gp2, 'N', 51, 20, 44, 412, 'E', 13, 52, 35, 544); - Geopoint gp2a = new Geopoint(String.valueOf(gp2.getLatDir()), String.valueOf(gp2.getLatDeg()), String.valueOf(gp2.getLatMin()), String.valueOf(gp2.getLatSec()), String.valueOf(gp2.getLatSecFrac()), + final Geopoint gp2a = new Geopoint(String.valueOf(gp2.getLatDir()), String.valueOf(gp2.getLatDeg()), String.valueOf(gp2.getLatMin()), String.valueOf(gp2.getLatSec()), String.valueOf(gp2.getLatSecFrac()), String.valueOf(gp2.getLonDir()), String.valueOf(gp2.getLonDeg()), String.valueOf(gp2.getLonMin()), String.valueOf(gp2.getLonSec()), String.valueOf(gp2.getLonSecFrac())); checkTolerance(gp2, gp2a, 5e-6); @@ -201,7 +201,7 @@ public class GeopointTest extends AndroidTestCase { checkDMS(gp3, 'N', 51, 17, 59, 994, 'E', 13, 48, 0, 0); - Geopoint gp3a = new Geopoint(String.valueOf(gp3.getLatDir()), String.valueOf(gp3.getLatDeg()), String.valueOf(gp3.getLatMin()), String.valueOf(gp3.getLatSec()), String.valueOf(gp3.getLatSecFrac()), + final Geopoint gp3a = new Geopoint(String.valueOf(gp3.getLatDir()), String.valueOf(gp3.getLatDeg()), String.valueOf(gp3.getLatMin()), String.valueOf(gp3.getLatSec()), String.valueOf(gp3.getLatSecFrac()), String.valueOf(gp3.getLonDir()), String.valueOf(gp3.getLonDeg()), String.valueOf(gp3.getLonMin()), String.valueOf(gp3.getLonSec()), String.valueOf(gp3.getLonSecFrac())); checkTolerance(gp3, gp3a, 5e-6); @@ -211,7 +211,7 @@ public class GeopointTest extends AndroidTestCase { checkDMS(gp4, 'N', 51, 0, 0, 432, 'E', 13, 0, 3, 204); - Geopoint gp4a = new Geopoint(String.valueOf(gp4.getLatDir()), String.valueOf(gp4.getLatDeg()), String.valueOf(gp4.getLatMin()), String.valueOf(gp4.getLatSec()), String.valueOf(gp4.getLatSecFrac()), + final Geopoint gp4a = new Geopoint(String.valueOf(gp4.getLatDir()), String.valueOf(gp4.getLatDeg()), String.valueOf(gp4.getLatMin()), String.valueOf(gp4.getLatSec()), String.valueOf(gp4.getLatSecFrac()), String.valueOf(gp4.getLonDir()), String.valueOf(gp4.getLonDeg()), String.valueOf(gp4.getLonMin()), String.valueOf(gp4.getLonSec()), String.valueOf(gp4.getLonSecFrac())); checkTolerance(gp4, gp4a, 5e-6); @@ -254,7 +254,7 @@ public class GeopointTest extends AndroidTestCase { }); } - public static void testParseParam2() throws Exception { + public static void testParseParam2() { assertParseException(new Runnable() { @SuppressWarnings("unused") @@ -265,7 +265,7 @@ public class GeopointTest extends AndroidTestCase { }); } - public static void testParseParam6() throws Exception { + public static void testParseParam6() { assertParseException(new Runnable() { @SuppressWarnings("unused") @@ -276,7 +276,7 @@ public class GeopointTest extends AndroidTestCase { }); } - public static void testParseParam8() throws Exception { + public static void testParseParam8() { assertParseException(new Runnable() { @SuppressWarnings("unused") @@ -287,7 +287,7 @@ public class GeopointTest extends AndroidTestCase { }); } - public static void testParseParam10() throws Exception { + public static void testParseParam10() { assertParseException(new Runnable() { @SuppressWarnings("unused") diff --git a/tests/src/cgeo/geocaching/sorting/DistanceComparatorTest.java b/tests/src/cgeo/geocaching/sorting/DistanceComparatorTest.java index 91896a5..2db3f59 100644 --- a/tests/src/cgeo/geocaching/sorting/DistanceComparatorTest.java +++ b/tests/src/cgeo/geocaching/sorting/DistanceComparatorTest.java @@ -1,6 +1,6 @@ package cgeo.geocaching.sorting; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.geopoint.Geopoint; import android.test.AndroidTestCase; @@ -12,9 +12,9 @@ import java.util.List; public class DistanceComparatorTest extends AndroidTestCase { public static void testCompareCaches() { - final List<cgCache> caches = new ArrayList<cgCache>(); + final List<Geocache> caches = new ArrayList<Geocache>(); for (int i = 0; i < 37; i++) { - cgCache cache = new cgCache(); + Geocache cache = new Geocache(); if (i % 3 == 0) { cache.setCoords(new Geopoint(i, i)); } diff --git a/tests/src/cgeo/geocaching/sorting/NameComparatorTest.java b/tests/src/cgeo/geocaching/sorting/NameComparatorTest.java index fa3b16c..18db4b7 100644 --- a/tests/src/cgeo/geocaching/sorting/NameComparatorTest.java +++ b/tests/src/cgeo/geocaching/sorting/NameComparatorTest.java @@ -1,25 +1,19 @@ package cgeo.geocaching.sorting; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import android.test.AndroidTestCase; public class NameComparatorTest extends AndroidTestCase { - private static class NamedCache extends cgCache { + private static class NamedCache extends Geocache { public NamedCache(final String name) { this.setName(name); } } - private NameComparator comp; - - @Override - protected void setUp() throws Exception { - super.setUp(); - comp = new NameComparator(); - } + private NameComparator comp = new NameComparator(); public void testLexical() { assertSorted(new NamedCache("A"), new NamedCache("Z")); @@ -37,11 +31,11 @@ public class NameComparatorTest extends AndroidTestCase { assertEquals("abc000123def456", (new NamedCache("abc123def456")).getNameForSorting()); } - private void assertSorted(final cgCache cache1, final cgCache cache2) { + private void assertSorted(final Geocache cache1, final Geocache cache2) { assertTrue(comp.compare(cache1, cache2) < 0); } - private void assertNotSorted(final cgCache cache1, final cgCache cache2) { + private void assertNotSorted(final Geocache cache1, final Geocache cache2) { assertTrue(comp.compare(cache1, cache2) > 0); } } 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) { diff --git a/tests/src/cgeo/geocaching/test/RegExPerformanceTest.java b/tests/src/cgeo/geocaching/test/RegExPerformanceTest.java index b9f8138..ec84824 100644 --- a/tests/src/cgeo/geocaching/test/RegExPerformanceTest.java +++ b/tests/src/cgeo/geocaching/test/RegExPerformanceTest.java @@ -8,6 +8,7 @@ import cgeo.geocaching.test.mock.MockedCache; import cgeo.geocaching.utils.BaseUtils; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.regex.Pattern; @@ -69,10 +70,13 @@ public class RegExPerformanceTest extends TestCase { public final static Pattern PATTERN_DESCRIPTION = Pattern.compile("<span id=\"ctl00_ContentBody_LongDescription\">(.*?)</span>[^<]*</div>[^<]*<p>[^<]*</p>[^<]*<p>[^<]*<strong>\\W*Additional Hints</strong>"); - public final static MockedCache[] MOCKED_CACHES = { new GC2CJPF(), new GC1ZXX2(), new GC2JVEH(), new GC3XX5J() }; + public final static List<MockedCache> MOCKED_CACHES; + static { + MOCKED_CACHES = Arrays.asList(new GC2CJPF(), new GC1ZXX2(), new GC2JVEH(), new GC3XX5J()); + } public static void testRegEx() { - List<String> output = doTheTests(10); + final List<String> output = doTheTests(10); for (String s : output) { System.out.println(s); @@ -81,7 +85,7 @@ public class RegExPerformanceTest extends TestCase { public static List<String> doTheTests(final int iterations) { - List<String> output = new ArrayList<String>(); + final List<String> output = new ArrayList<String>(); output.addAll(measure(iterations, "description", PATTERN_DESCRIPTION_OLD, PATTERN_DESCRIPTION)); @@ -90,7 +94,7 @@ public class RegExPerformanceTest extends TestCase { private static List<String> measure(int iterations, String fieldName, Pattern p1, Pattern p2) { - List<String> output = new ArrayList<String>(); + final List<String> output = new ArrayList<String>(); output.add(fieldName + ":"); for (MockedCache cache : MOCKED_CACHES) { @@ -102,15 +106,13 @@ public class RegExPerformanceTest extends TestCase { long diff1, diff2; output.add("Parsing " + cache.getGeocode() + " " + cache.getName()); - { - diff1 = parse(page, p1, iterations); - output.add("Time pattern 1:\t" + diff1 + " ms"); - } - - { - diff2 = parse(page, p2, iterations); - output.add("Time pattern 2:\t" + diff2 + " ms"); - } + + diff1 = parse(page, p1, iterations); + output.add("Time pattern 1:\t" + diff1 + " ms"); + + diff2 = parse(page, p2, iterations); + output.add("Time pattern 2:\t" + diff2 + " ms"); + float reduction = (float) diff2 * 100 / diff1; output.add("New runtime:\t" + String.format("%.1f", reduction) + "%\n"); } @@ -120,11 +122,11 @@ public class RegExPerformanceTest extends TestCase { } private static long parse(String page, Pattern pattern, int iterations) { - long start = System.currentTimeMillis(); + final long start = System.currentTimeMillis(); for (int j = 0; j < iterations; j++) { BaseUtils.getMatch(page, pattern, true, ""); } - return (System.currentTimeMillis() - start); + return System.currentTimeMillis() - start; } diff --git a/tests/src/cgeo/geocaching/test/RegExRealPerformanceTest.java b/tests/src/cgeo/geocaching/test/RegExRealPerformanceTest.java index 3867082..07c4c95 100644 --- a/tests/src/cgeo/geocaching/test/RegExRealPerformanceTest.java +++ b/tests/src/cgeo/geocaching/test/RegExRealPerformanceTest.java @@ -17,7 +17,7 @@ public class RegExRealPerformanceTest extends AndroidTestCase { public static void testRegEx() { - List<String> output = RegExPerformanceTest.doTheTests(10); + final List<String> output = RegExPerformanceTest.doTheTests(10); for (String s : output) { Log.d(s); diff --git a/tests/src/cgeo/geocaching/test/WhitespaceTest.java b/tests/src/cgeo/geocaching/test/WhitespaceTest.java index a78f2fa..6138755 100644 --- a/tests/src/cgeo/geocaching/test/WhitespaceTest.java +++ b/tests/src/cgeo/geocaching/test/WhitespaceTest.java @@ -57,10 +57,10 @@ public class WhitespaceTest extends AbstractResourceInstrumentationTestCase { } public void testRegex() { - Pattern pattern = Pattern.compile("\\s+"); + final Pattern pattern = Pattern.compile("\\s+"); final long start = System.currentTimeMillis(); - Matcher matcher = pattern.matcher(data); - String result = matcher.replaceAll(" ").trim(); + final Matcher matcher = pattern.matcher(data); + final String result = matcher.replaceAll(" ").trim(); final long end = System.currentTimeMillis(); assertEquals(EXPECTED_SIZE - 1, result.length()); Log.d((end - start) + " ms regex"); @@ -68,14 +68,14 @@ public class WhitespaceTest extends AbstractResourceInstrumentationTestCase { public void testReplaceAll() { final long start = System.currentTimeMillis(); - String result = data.replaceAll("\\s+", " "); + final String result = data.replaceAll("\\s+", " "); final long end = System.currentTimeMillis(); assertEquals(EXPECTED_SIZE + 1, result.length()); Log.d((end - start) + " ms replaceAll"); } public void testActualImplementation() { - String result; + final String result; final long start = System.currentTimeMillis(); result = BaseUtils.replaceWhitespace(data); final long end = System.currentTimeMillis(); @@ -84,7 +84,7 @@ public class WhitespaceTest extends AbstractResourceInstrumentationTestCase { } public void testManually() { - String result; + final String result; final long start = System.currentTimeMillis(); result = replaceWhitespaceManually(data); final long end = System.currentTimeMillis(); @@ -93,7 +93,7 @@ public class WhitespaceTest extends AbstractResourceInstrumentationTestCase { } public void testStringUtils() { - String result; + final String result; final long start = System.currentTimeMillis(); result = replaceWhitespaceStringUtils(data); final long end = System.currentTimeMillis(); diff --git a/tests/src/cgeo/geocaching/test/mock/GC1ZXX2.java b/tests/src/cgeo/geocaching/test/mock/GC1ZXX2.java index e566ca2..6de8f4f 100644 --- a/tests/src/cgeo/geocaching/test/mock/GC1ZXX2.java +++ b/tests/src/cgeo/geocaching/test/mock/GC1ZXX2.java @@ -5,11 +5,11 @@ import cgeo.geocaching.enumerations.CacheSize; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.enumerations.LogType; import cgeo.geocaching.geopoint.Geopoint; -import cgeo.geocaching.utils.LazyInitializedList; import java.text.ParseException; import java.util.Date; import java.util.HashMap; +import java.util.List; import java.util.Map; @@ -95,8 +95,8 @@ public class GC1ZXX2 extends MockedCache { } @Override - public LazyInitializedList<String> getAttributes() { - String[] attributes = new String[] { + public List<String> getAttributes() { + final String[] attributes = new String[] { "bicycles_yes", "available_yes", "stroller_yes", @@ -111,7 +111,7 @@ public class GC1ZXX2 extends MockedCache { @Override public Map<LogType, Integer> getLogCounts() { - Map<LogType, Integer> logCounts = new HashMap<LogType, Integer>(); + final Map<LogType, Integer> logCounts = new HashMap<LogType, Integer>(); logCounts.put(LogType.PUBLISH_LISTING, 1); logCounts.put(LogType.FOUND_IT, 368); logCounts.put(LogType.POST_REVIEWER_NOTE, 1); diff --git a/tests/src/cgeo/geocaching/test/mock/GC2CJPF.java b/tests/src/cgeo/geocaching/test/mock/GC2CJPF.java index cc19eb3..107384f 100644 --- a/tests/src/cgeo/geocaching/test/mock/GC2CJPF.java +++ b/tests/src/cgeo/geocaching/test/mock/GC2CJPF.java @@ -6,11 +6,11 @@ import cgeo.geocaching.enumerations.CacheSize; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.enumerations.LogType; import cgeo.geocaching.geopoint.Geopoint; -import cgeo.geocaching.utils.LazyInitializedList; import java.text.ParseException; import java.util.Date; import java.util.HashMap; +import java.util.List; import java.util.Map; @@ -103,11 +103,11 @@ public class GC2CJPF extends MockedCache { * @see cgeo.geocaching.test.mock.MockedCache#isOwn() */ @Override - public boolean isOwn() { + public boolean isOwner() { if ("Tom03".equals(Settings.getUsername())) { return true; } - return super.isOwn(); + return super.isOwner(); } @Override @@ -129,8 +129,8 @@ public class GC2CJPF extends MockedCache { } @Override - public LazyInitializedList<String> getAttributes() { - String[] attributes = new String[] { + public List<String> getAttributes() { + final String[] attributes = new String[] { "motorcycles_no", "wheelchair_no", "winter_yes", @@ -147,7 +147,7 @@ public class GC2CJPF extends MockedCache { @Override public Map<LogType, Integer> getLogCounts() { - Map<LogType, Integer> logCounts = new HashMap<LogType, Integer>(); + final Map<LogType, Integer> logCounts = new HashMap<LogType, Integer>(); logCounts.put(LogType.PUBLISH_LISTING, 1); logCounts.put(LogType.FOUND_IT, 119); logCounts.put(LogType.DIDNT_FIND_IT, 3); diff --git a/tests/src/cgeo/geocaching/test/mock/GC2JVEH.java b/tests/src/cgeo/geocaching/test/mock/GC2JVEH.java index 9aa18f9..9557991 100644 --- a/tests/src/cgeo/geocaching/test/mock/GC2JVEH.java +++ b/tests/src/cgeo/geocaching/test/mock/GC2JVEH.java @@ -1,13 +1,12 @@ package cgeo.geocaching.test.mock; -import cgeo.geocaching.cgImage; -import cgeo.geocaching.cgTrackable; +import cgeo.geocaching.Image; +import cgeo.geocaching.Trackable; import cgeo.geocaching.connector.gc.Login; import cgeo.geocaching.enumerations.CacheSize; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.enumerations.LogType; import cgeo.geocaching.geopoint.Geopoint; -import cgeo.geocaching.utils.LazyInitializedList; import java.text.ParseException; import java.util.ArrayList; @@ -98,7 +97,7 @@ public class GC2JVEH extends MockedCache { } @Override - public LazyInitializedList<String> getAttributes() { + public List<String> getAttributes() { final String[] attributes = new String[] { "winter_yes", "flashlight_yes", @@ -133,16 +132,16 @@ public class GC2JVEH extends MockedCache { } @Override - public List<cgTrackable> getInventory() { - final ArrayList<cgTrackable> inventory = new ArrayList<cgTrackable>(); - inventory.add(new cgTrackable()); + public List<Trackable> getInventory() { + final ArrayList<Trackable> inventory = new ArrayList<Trackable>(); + inventory.add(new Trackable()); return inventory; } @Override - public List<cgImage> getSpoilers() { - final ArrayList<cgImage> spoilers = new ArrayList<cgImage>(); - final cgImage mockedImage = new cgImage(null, null, null); + public List<Image> getSpoilers() { + final ArrayList<Image> spoilers = new ArrayList<Image>(); + final Image mockedImage = new Image(null, null, null); spoilers.add(mockedImage); spoilers.add(mockedImage); spoilers.add(mockedImage); diff --git a/tests/src/cgeo/geocaching/test/mock/GC3XX5J.java b/tests/src/cgeo/geocaching/test/mock/GC3XX5J.java index 540ae12..b598cfa 100644 --- a/tests/src/cgeo/geocaching/test/mock/GC3XX5J.java +++ b/tests/src/cgeo/geocaching/test/mock/GC3XX5J.java @@ -5,11 +5,11 @@ import cgeo.geocaching.enumerations.CacheSize; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.enumerations.LogType; import cgeo.geocaching.geopoint.Geopoint; -import cgeo.geocaching.utils.LazyInitializedList; import java.text.ParseException; import java.util.Date; import java.util.HashMap; +import java.util.List; import java.util.Map; @@ -95,8 +95,8 @@ public class GC3XX5J extends MockedCache { } @Override - public LazyInitializedList<String> getAttributes() { - String[] attributes = new String[] { + public List<String> getAttributes() { + final String[] attributes = new String[] { "stroller_no", "kids_no", "bicycles_yes", @@ -114,7 +114,7 @@ public class GC3XX5J extends MockedCache { @Override public Map<LogType, Integer> getLogCounts() { - Map<LogType, Integer> logCounts = new HashMap<LogType, Integer>(); + final Map<LogType, Integer> logCounts = new HashMap<LogType, Integer>(); logCounts.put(LogType.PUBLISH_LISTING, 2); logCounts.put(LogType.FOUND_IT, 65); logCounts.put(LogType.RETRACT, 1); diff --git a/tests/src/cgeo/geocaching/test/mock/MockedCache.java b/tests/src/cgeo/geocaching/test/mock/MockedCache.java index 352c34d..7ad566a 100644 --- a/tests/src/cgeo/geocaching/test/mock/MockedCache.java +++ b/tests/src/cgeo/geocaching/test/mock/MockedCache.java @@ -1,8 +1,8 @@ package cgeo.geocaching.test.mock; import cgeo.geocaching.ICache; -import cgeo.geocaching.cgImage; -import cgeo.geocaching.cgTrackable; +import cgeo.geocaching.Image; +import cgeo.geocaching.Trackable; import cgeo.geocaching.connector.gc.GCConstants; import cgeo.geocaching.geopoint.Geopoint; import cgeo.geocaching.utils.BaseUtils; @@ -70,7 +70,7 @@ public abstract class MockedCache implements ICache { return BaseUtils.replaceWhitespace(buffer.toString()); } catch (IOException e) { - e.printStackTrace(); + Assert.fail(e.getMessage()); } finally { IOUtils.closeQuietly(is); IOUtils.closeQuietly(br); @@ -94,7 +94,7 @@ public abstract class MockedCache implements ICache { } @Override - public boolean isOwn() { + public boolean isOwner() { return false; } @@ -134,12 +134,12 @@ public abstract class MockedCache implements ICache { } @Override - public List<cgTrackable> getInventory() { + public List<Trackable> getInventory() { return null; } @Override - public List<cgImage> getSpoilers() { + public List<Image> getSpoilers() { return null; } diff --git a/tests/src/cgeo/geocaching/test/mock/MockedLazyInitializedList.java b/tests/src/cgeo/geocaching/test/mock/MockedLazyInitializedList.java index a3dd5e3..b67efda 100644 --- a/tests/src/cgeo/geocaching/test/mock/MockedLazyInitializedList.java +++ b/tests/src/cgeo/geocaching/test/mock/MockedLazyInitializedList.java @@ -9,11 +9,12 @@ import java.util.List; class MockedLazyInitializedList<ElementType> extends LazyInitializedList<ElementType> { public MockedLazyInitializedList(ElementType[] elements) { - set(Arrays.asList(elements)); + clear(); + addAll(Arrays.asList(elements)); } @Override - protected List<ElementType> loadFromDatabase() { + public List<ElementType> call() { return new ArrayList<ElementType>(); } diff --git a/tests/src/cgeo/geocaching/ui/FormatterTest.java b/tests/src/cgeo/geocaching/ui/FormatterTest.java new file mode 100644 index 0000000..e65f425 --- /dev/null +++ b/tests/src/cgeo/geocaching/ui/FormatterTest.java @@ -0,0 +1,30 @@ +package cgeo.geocaching.ui; + +import cgeo.geocaching.R; +import cgeo.geocaching.Waypoint; +import cgeo.geocaching.cgeoapplication; +import cgeo.geocaching.enumerations.WaypointType; + +import android.test.AndroidTestCase; + +public class FormatterTest extends AndroidTestCase { + + public static void testParkingWaypoint() { + assertFormatting(new Waypoint("you can park here", WaypointType.PARKING, false), WaypointType.PARKING.getL10n()); + } + + public static void testOriginalWaypoint() { + assertFormatting(new Waypoint("an original", WaypointType.ORIGINAL, false), WaypointType.ORIGINAL.getL10n()); + } + + public static void testOwnWaypoint() { + final Waypoint own = new Waypoint("my own", WaypointType.OWN, true); + own.setPrefix(Waypoint.PREFIX_OWN); + assertFormatting(own, cgeoapplication.getInstance().getString(R.string.waypoint_custom)); + } + + private static void assertFormatting(Waypoint waypoint, String expected) { + assertEquals(expected, Formatter.formatWaypointInfo(waypoint)); + } + +} diff --git a/tests/src/cgeo/geocaching/utils/BaseUtilsTest.java b/tests/src/cgeo/geocaching/utils/BaseUtilsTest.java index 2cedb2f..07ad7fe 100644 --- a/tests/src/cgeo/geocaching/utils/BaseUtilsTest.java +++ b/tests/src/cgeo/geocaching/utils/BaseUtilsTest.java @@ -9,7 +9,7 @@ import java.util.regex.Pattern; public class BaseUtilsTest extends AndroidTestCase { public static void testRegEx() { - String page = MockedCache.readCachePage("GC2CJPF"); + final String page = MockedCache.readCachePage("GC2CJPF"); assertEquals("blafoo", BaseUtils.getMatch(page, GCConstants.PATTERN_LOGIN_NAME, true, "???")); assertTrue(page.contains("id=\"ctl00_hlRenew\"") || GCConstants.MEMBER_STATUS_PM.equals(BaseUtils.getMatch(page, GCConstants.PATTERN_MEMBER_STATUS, true, "???"))); int cachesFound = 0; @@ -26,7 +26,7 @@ public class BaseUtilsTest extends AndroidTestCase { } public static void testControlCharactersCleanup() { - Pattern patternAll = Pattern.compile("(.*)", Pattern.DOTALL); + final Pattern patternAll = Pattern.compile("(.*)", Pattern.DOTALL); assertEquals("some control characters removed", BaseUtils.getMatch("some" + "\u001C" + "control" + (char) 0x1D + "characters removed", patternAll, "")); assertEquals("newline also removed", BaseUtils.getMatch("newline\nalso\nremoved", patternAll, "")); } diff --git a/tests/src/cgeo/geocaching/utils/CryptUtilsTest.java b/tests/src/cgeo/geocaching/utils/CryptUtilsTest.java index d092cd8..fff24f2 100644 --- a/tests/src/cgeo/geocaching/utils/CryptUtilsTest.java +++ b/tests/src/cgeo/geocaching/utils/CryptUtilsTest.java @@ -18,7 +18,7 @@ public class CryptUtilsTest extends TestCase { assertEquals(61731, GCConstants.gccodeToGCId("GCF123")); } - public static void testIssue1902() throws Exception { + public static void testIssue1902() { assertEquals("ƖƖlƖƖƖƖ", CryptUtils.rot13("ƖƖyƖƖƖƖ")); } } diff --git a/tests/src/cgeo/geocaching/utils/DateUtilsTest.java b/tests/src/cgeo/geocaching/utils/DateUtilsTest.java index caf5e3c..0a9d3e3 100644 --- a/tests/src/cgeo/geocaching/utils/DateUtilsTest.java +++ b/tests/src/cgeo/geocaching/utils/DateUtilsTest.java @@ -7,7 +7,7 @@ import junit.framework.TestCase; public class DateUtilsTest extends TestCase { public static void testDaysSince() { - Calendar start = Calendar.getInstance(); + final Calendar start = Calendar.getInstance(); for (int hour = 0; hour < 24; hour++) { start.set(Calendar.HOUR_OF_DAY, hour); assertEquals(0, DateUtils.daysSince(start.getTimeInMillis())); diff --git a/tests/src/cgeo/geocaching/utils/HtmlUtilsTest.java b/tests/src/cgeo/geocaching/utils/HtmlUtilsTest.java new file mode 100644 index 0000000..52b816e --- /dev/null +++ b/tests/src/cgeo/geocaching/utils/HtmlUtilsTest.java @@ -0,0 +1,11 @@ +package cgeo.geocaching.utils; + +import junit.framework.TestCase; + +public class HtmlUtilsTest extends TestCase { + + public static void testNonLatinCharConv() { + final String res = HtmlUtils.convertNonLatinCharactersToHTML("abcΦςቡぢれ"); + assertEquals("abcΦςቡぢれ", res); + } +} diff --git a/tests/src/cgeo/geocaching/utils/LazyInitializedListTest.java b/tests/src/cgeo/geocaching/utils/LazyInitializedListTest.java index b3eaedf..c0be156 100644 --- a/tests/src/cgeo/geocaching/utils/LazyInitializedListTest.java +++ b/tests/src/cgeo/geocaching/utils/LazyInitializedListTest.java @@ -1,15 +1,15 @@ package cgeo.geocaching.utils; +import junit.framework.TestCase; + import java.util.ArrayList; import java.util.List; -import junit.framework.TestCase; - public class LazyInitializedListTest extends TestCase { private static final class MockedLazyInitializedList extends LazyInitializedList<String> { @Override - protected List<String> loadFromDatabase() { + public List<String> call() { return new ArrayList<String>(); } } @@ -28,20 +28,4 @@ public class LazyInitializedListTest extends TestCase { assertEquals(1, iterations); } - public static void testNull() { - final LazyInitializedList<String> list = new MockedLazyInitializedList(); - list.set((LazyInitializedList<String>) null); - list.set((ArrayList<String>) null); - } - - public static void testUnmodifiable() { - final MockedLazyInitializedList list = new MockedLazyInitializedList(); - boolean unsupported = false; - try { - list.asList().add("this is not possible"); - } catch (UnsupportedOperationException e) { - unsupported = true; - } - assertTrue(unsupported); - } } diff --git a/tests/src/cgeo/geocaching/utils/LeastRecentlyUsedMapTest.java b/tests/src/cgeo/geocaching/utils/LeastRecentlyUsedMapTest.java index 723b7153..11088e2 100644 --- a/tests/src/cgeo/geocaching/utils/LeastRecentlyUsedMapTest.java +++ b/tests/src/cgeo/geocaching/utils/LeastRecentlyUsedMapTest.java @@ -1,6 +1,6 @@ package cgeo.geocaching.utils; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import java.util.Map; @@ -45,11 +45,11 @@ public class LeastRecentlyUsedMapTest extends AbstractLRUTest { } public static void testRemoveEldestEntry() { - final LeastRecentlyUsedMap<String, cgCache> cache = new LeastRecentlyUsedMap.LruCache<String, cgCache>(10); - final cgCache first = new cgCache(); + final LeastRecentlyUsedMap<String, Geocache> cache = new LeastRecentlyUsedMap.LruCache<String, Geocache>(10); + final Geocache first = new Geocache(); assertNull(cache.put("1", first)); - final cgCache second = new cgCache(); + final Geocache second = new Geocache(); assertNull(cache.put("2", second)); assertEquals(2, cache.size()); @@ -59,7 +59,7 @@ public class LeastRecentlyUsedMapTest extends AbstractLRUTest { assertTrue(cache.containsValue(second)); for (int i = 3; i <= 10; i++) { - assertNull(cache.put(Integer.toString(i), new cgCache())); + assertNull(cache.put(Integer.toString(i), new Geocache())); } assertEquals(10, cache.size()); @@ -69,8 +69,8 @@ public class LeastRecentlyUsedMapTest extends AbstractLRUTest { assertTrue(cache.containsValue(second)); assertNotNull(cache.remove("1")); // just replacing the old entry would not work - assertNull(cache.put("1", new cgCache())); - assertNull(cache.put("11", new cgCache())); + assertNull(cache.put("1", new Geocache())); + assertNull(cache.put("11", new Geocache())); assertEquals(10, cache.size()); diff --git a/tests/src/cgeo/geocaching/utils/LeastRecentlyUsedSetTest.java b/tests/src/cgeo/geocaching/utils/LeastRecentlyUsedSetTest.java index 4b4e5f7..7e06b83 100644 --- a/tests/src/cgeo/geocaching/utils/LeastRecentlyUsedSetTest.java +++ b/tests/src/cgeo/geocaching/utils/LeastRecentlyUsedSetTest.java @@ -1,6 +1,6 @@ package cgeo.geocaching.utils; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import java.util.Set; @@ -26,12 +26,12 @@ public class LeastRecentlyUsedSetTest extends AbstractLRUTest { } public static void testRemoveEldestEntry() { - final LeastRecentlyUsedSet<cgCache> caches = new LeastRecentlyUsedSet<cgCache>(10); - final cgCache first = new cgCache(); + final LeastRecentlyUsedSet<Geocache> caches = new LeastRecentlyUsedSet<Geocache>(10); + final Geocache first = new Geocache(); first.setGeocode("1"); assertTrue(caches.add(first)); - final cgCache second = new cgCache(); + final Geocache second = new Geocache(); second.setGeocode("2"); assertTrue(caches.add(second)); @@ -44,7 +44,7 @@ public class LeastRecentlyUsedSetTest extends AbstractLRUTest { assertEquals(2, caches.size()); for (int i = 3; i <= 10; i++) { - final cgCache cache = new cgCache(); + final Geocache cache = new Geocache(); cache.setGeocode(Integer.toString(i)); assertTrue(caches.add(cache)); } @@ -53,7 +53,7 @@ public class LeastRecentlyUsedSetTest extends AbstractLRUTest { assertTrue(caches.contains(first)); assertTrue(caches.contains(second)); - final cgCache c11 = new cgCache(); + final Geocache c11 = new Geocache(); c11.setGeocode("11"); assertTrue(caches.add(c11)); diff --git a/tests/src/cgeo/geocaching/utils/MemorySubjectTest.java b/tests/src/cgeo/geocaching/utils/MemorySubjectTest.java index 7b30180..ee46950 100644 --- a/tests/src/cgeo/geocaching/utils/MemorySubjectTest.java +++ b/tests/src/cgeo/geocaching/utils/MemorySubjectTest.java @@ -5,8 +5,8 @@ import android.test.AndroidTestCase; public class MemorySubjectTest extends AndroidTestCase { private static class Observer implements IObserver<Integer> { - public int times = 0; - public Integer value; + private int times = 0; + private Integer value; @Override public void update(final Integer data) { diff --git a/tests/src/cgeo/test/Compare.java b/tests/src/cgeo/test/Compare.java index 4d0e08e..8af1541 100644 --- a/tests/src/cgeo/test/Compare.java +++ b/tests/src/cgeo/test/Compare.java @@ -4,12 +4,12 @@ import static junit.framework.Assert.assertEquals; import static junit.framework.Assert.assertTrue; import cgeo.geocaching.ICache; -import cgeo.geocaching.cgCache; +import cgeo.geocaching.Geocache; import cgeo.geocaching.enumerations.LogType; public abstract class Compare { - public static void assertCompareCaches(ICache expected, cgCache actual, boolean all) { + public static void assertCompareCaches(ICache expected, Geocache actual, boolean all) { assertEquals(expected.getGeocode(), actual.getGeocode()); assertTrue(expected.getType() == actual.getType()); assertEquals(expected.getOwnerDisplayName(), actual.getOwnerDisplayName()); @@ -27,7 +27,7 @@ public abstract class Compare { if (all) { assertEquals(expected.getCoords(), actual.getCoords()); assertTrue(actual.isReliableLatLon()); - assertEquals(expected.isOwn(), actual.isOwn()); + assertEquals(expected.isOwner(), actual.isOwner()); assertEquals(expected.getOwnerUserId(), actual.getOwnerUserId()); assertEquals(expected.getHint(), actual.getHint()); assertTrue(actual.getDescription().startsWith(expected.getDescription())); @@ -48,8 +48,8 @@ public abstract class Compare { // The inventories can differ too often, therefore we don't compare them. Also, the personal note // cannot be expected to match with different tester accounts. - int actualSpoilersSize = null != actual.getSpoilers() ? actual.getSpoilers().size() : 0; - int expectedSpoilersSize = null != expected.getSpoilers() ? expected.getSpoilers().size() : 0; + final int actualSpoilersSize = null != actual.getSpoilers() ? actual.getSpoilers().size() : 0; + final int expectedSpoilersSize = null != expected.getSpoilers() ? expected.getSpoilers().size() : 0; assertEquals(expectedSpoilersSize, actualSpoilersSize); } } |