diff options
Diffstat (limited to 'tests')
20 files changed, 340 insertions, 120 deletions
diff --git a/tests/src/cgeo/CGeoTestCase.java b/tests/src/cgeo/CGeoTestCase.java index 6a63cbc..7dd5956 100644 --- a/tests/src/cgeo/CGeoTestCase.java +++ b/tests/src/cgeo/CGeoTestCase.java @@ -1,15 +1,24 @@ package cgeo; -import cgeo.geocaching.cgData; -import cgeo.geocaching.cgeoapplication; +import cgeo.geocaching.CgeoApplication; +import cgeo.geocaching.DataStore; import cgeo.geocaching.enumerations.LoadFlags; +import cgeo.geocaching.enumerations.LoadFlags.RemoveFlag; +import cgeo.geocaching.settings.Settings; +import cgeo.geocaching.settings.TestSettings; import android.test.ApplicationTestCase; -public abstract class CGeoTestCase extends ApplicationTestCase<cgeoapplication> { +import java.util.EnumSet; + +public abstract class CGeoTestCase extends ApplicationTestCase<CgeoApplication> { + + private boolean oldStoreMapsFlag; + private boolean oldStoreWpMapsFlag; + private boolean oldMapStoreFlagsRecorded = false; public CGeoTestCase() { - super(cgeoapplication.class); + super(CgeoApplication.class); } @Override @@ -20,7 +29,58 @@ public abstract class CGeoTestCase extends ApplicationTestCase<cgeoapplication> /** 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); + DataStore.removeCache(geocode, LoadFlags.REMOVE_ALL); + } + + /** + * remove cache from database and file system + * + * @param geocode + */ + 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); + DataStore.removeCache(geocode, flags); + } + + /** + * must be called once before setting the flags + * can be called again after restoring the flags + */ + protected void recordMapStoreFlags() { + if (oldMapStoreFlagsRecorded) { + throw new IllegalStateException("MapStoreFlags already recorded!"); + } + oldStoreMapsFlag = Settings.isStoreOfflineMaps(); + oldStoreWpMapsFlag = Settings.isStoreOfflineWpMaps(); + oldMapStoreFlagsRecorded = true; } + /** + * can be called after recordMapStoreFlags, + * to set the flags for map storing as necessary + * @param storeCacheMap + * @param storeWpMaps + */ + protected void setMapStoreFlags(boolean storeCacheMap, boolean storeWpMaps) { + if (!oldMapStoreFlagsRecorded) { + throw new IllegalStateException("Previous MapStoreFlags havn't been recorded! Setting not allowed"); + } + + TestSettings.setStoreOfflineMaps(storeCacheMap); + TestSettings.setStoreOfflineWpMaps(storeWpMaps); + } + + /** + * has to be called after completion of the test (preferably in the finally part of a try statement) + */ + protected void restoreMapStoreFlags() { + if (!oldMapStoreFlagsRecorded) { + throw new IllegalStateException("Previous MapStoreFlags havn't been recorded. Restore not possible"); + } + + TestSettings.setStoreOfflineMaps(oldStoreMapsFlag); + TestSettings.setStoreOfflineWpMaps(oldStoreWpMapsFlag); + oldMapStoreFlagsRecorded = false; + } } diff --git a/tests/src/cgeo/geocaching/cgDataTest.java b/tests/src/cgeo/geocaching/DataStoreTest.java index cacf061..3f0214b 100644 --- a/tests/src/cgeo/geocaching/cgDataTest.java +++ b/tests/src/cgeo/geocaching/DataStoreTest.java @@ -18,7 +18,7 @@ import java.util.HashSet; import java.util.List; import java.util.Set; -public class cgDataTest extends CGeoTestCase { +public class DataStoreTest extends CGeoTestCase { public static void testStoredLists() { @@ -35,11 +35,11 @@ public class cgDataTest extends CGeoTestCase { try { // create lists - listId1 = cgData.createList("cgData Test"); + listId1 = DataStore.createList("DataStore Test"); assertTrue(listId1 > StoredList.STANDARD_LIST_ID); - listId2 = cgData.createList("cgDataTest"); + listId2 = DataStore.createList("DataStoreTest"); assertTrue(listId2 > StoredList.STANDARD_LIST_ID); - assertTrue(cgData.getLists().size() >= 2); + assertTrue(DataStore.getLists().size() >= 2); cache1.setDetailed(true); cache1.setListId(listId1); @@ -47,33 +47,33 @@ public class cgDataTest extends CGeoTestCase { cache2.setListId(listId1); // save caches to DB (cache1=listId1, cache2=listId1) - cgData.saveCache(cache1, LoadFlags.SAVE_ALL); - cgData.saveCache(cache2, LoadFlags.SAVE_ALL); - assertTrue(cgData.getAllCachesCount() >= 2); + DataStore.saveCache(cache1, LoadFlags.SAVE_ALL); + DataStore.saveCache(cache2, LoadFlags.SAVE_ALL); + assertTrue(DataStore.getAllCachesCount() >= 2); // rename list (cache1=listId1, cache2=listId1) - assertEquals(1, cgData.renameList(listId1, "cgData Test (renamed)")); + assertEquals(1, DataStore.renameList(listId1, "DataStore Test (renamed)")); // get list - final StoredList list1 = cgData.getList(listId1); - assertEquals("cgData Test (renamed)", list1.title); + final StoredList list1 = DataStore.getList(listId1); + assertEquals("DataStore Test (renamed)", list1.title); // move to list (cache1=listId2, cache2=listId2) - cgData.moveToList(Collections.singletonList(cache1), listId2); - assertEquals(1, cgData.getAllStoredCachesCount(CacheType.ALL, listId2)); + DataStore.moveToList(Collections.singletonList(cache1), listId2); + assertEquals(1, DataStore.getAllStoredCachesCount(CacheType.ALL, listId2)); // remove list (cache1=listId2, cache2=listId2) - assertTrue(cgData.removeList(listId1)); + assertTrue(DataStore.removeList(listId1)); // mark dropped (cache1=1, cache2=0) - cgData.markDropped(Collections.singletonList(cache2)); + DataStore.markDropped(Collections.singletonList(cache2)); // mark stored (cache1=1, cache2=listId2) - cgData.moveToList(Collections.singletonList(cache2), listId2); - assertEquals(2, cgData.getAllStoredCachesCount(CacheType.ALL, listId2)); + DataStore.moveToList(Collections.singletonList(cache2), listId2); + assertEquals(2, DataStore.getAllStoredCachesCount(CacheType.ALL, listId2)); // drop stored (cache1=0, cache2=0) - cgData.removeList(listId2); + DataStore.removeList(listId2); } finally { @@ -81,25 +81,25 @@ public class cgDataTest extends CGeoTestCase { final Set<String> geocodes = new HashSet<String>(); geocodes.add(cache1.getGeocode()); geocodes.add(cache2.getGeocode()); - cgData.removeCaches(geocodes, LoadFlags.REMOVE_ALL); + DataStore.removeCaches(geocodes, LoadFlags.REMOVE_ALL); // remove list - cgData.removeList(listId1); - cgData.removeList(listId2); + DataStore.removeList(listId1); + DataStore.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)); - 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); + DataStore.loadWaypoints(viewport, false, false, CacheType.ALL); + DataStore.loadWaypoints(viewport, false, true, CacheType.ALL); + DataStore.loadWaypoints(viewport, true, false, CacheType.ALL); + DataStore.loadWaypoints(viewport, true, true, CacheType.ALL); + DataStore.loadWaypoints(viewport, false, false, CacheType.TRADITIONAL); + DataStore.loadWaypoints(viewport, false, true, CacheType.TRADITIONAL); + DataStore.loadWaypoints(viewport, true, false, CacheType.TRADITIONAL); + DataStore.loadWaypoints(viewport, true, true, CacheType.TRADITIONAL); } // Check that saving a cache and trackable without logs works (see #2199) @@ -118,12 +118,12 @@ public class cgDataTest extends CGeoTestCase { cache.setInventory(inventory); try { - cgData.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB)); - final Geocache loadedCache = cgData.loadCache(GEOCODE_CACHE, LoadFlags.LOAD_ALL_DB_ONLY); + DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB)); + final Geocache loadedCache = DataStore.loadCache(GEOCODE_CACHE, LoadFlags.LOAD_ALL_DB_ONLY); assertNotNull("Cache was not saved!", loadedCache); assertEquals(1, loadedCache.getInventory().size()); } finally { - cgData.removeCache(GEOCODE_CACHE, LoadFlags.REMOVE_ALL); + DataStore.removeCache(GEOCODE_CACHE, LoadFlags.REMOVE_ALL); } } @@ -141,25 +141,25 @@ public class cgDataTest extends CGeoTestCase { cache.setDetailed(true); try { - final Geocache oldCache = cgData.loadCache(upperCase, LoadFlags.LOAD_ALL_DB_ONLY); + final Geocache oldCache = DataStore.loadCache(upperCase, LoadFlags.LOAD_ALL_DB_ONLY); assertNull("Database contained old cache!", oldCache); - cgData.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB)); - final Geocache cacheWithOriginalCode = cgData.loadCache(upperCase, LoadFlags.LOAD_ALL_DB_ONLY); + DataStore.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB)); + final Geocache cacheWithOriginalCode = DataStore.loadCache(upperCase, LoadFlags.LOAD_ALL_DB_ONLY); assertNotNull("Cache was not saved correctly!", cacheWithOriginalCode); - final Geocache cacheLowerCase = cgData.loadCache(lowerCase, LoadFlags.LOAD_ALL_DB_ONLY); + final Geocache cacheLowerCase = DataStore.loadCache(lowerCase, LoadFlags.LOAD_ALL_DB_ONLY); assertNotNull("Could not find cache by case insensitive geocode", cacheLowerCase); } finally { - cgData.removeCache(upperCase, LoadFlags.REMOVE_ALL); + DataStore.removeCache(upperCase, LoadFlags.REMOVE_ALL); } } // Loading logs for an empty geocode should return an empty list, not null! public static void testLoadLogsFromEmptyGeocode() { - final List<LogEntry> logs = cgData.loadLogs(""); + final List<LogEntry> logs = DataStore.loadLogs(""); assertNotNull("Logs must not be null", logs); assertEquals("Logs from empty geocode must be empty", 0, logs.size()); @@ -169,7 +169,7 @@ public class cgDataTest extends CGeoTestCase { int sumCaches = 0; int allCaches = 0; for (CacheType cacheType : CacheType.values()) { - SearchResult historyOfType = cgData.getHistoryOfCaches(false, cacheType); + SearchResult historyOfType = DataStore.getHistoryOfCaches(false, cacheType); assertNotNull(historyOfType); if (cacheType != CacheType.ALL) { sumCaches += historyOfType.getCount(); @@ -180,7 +180,7 @@ public class cgDataTest extends CGeoTestCase { // check that sum of types equals 'all' assertEquals(sumCaches, allCaches); // check that two different routines behave the same - assertEquals(cgData.getAllHistoryCachesCount(), sumCaches); + assertEquals(DataStore.getAllHistoryCachesCount(), sumCaches); } public static void testCachedMissing() { @@ -208,15 +208,15 @@ public class cgDataTest extends CGeoTestCase { inTileHighZoom.setCoords(new Geopoint("N49 44.001 E8 37.001"), Tile.ZOOMLEVEL_MIN_PERSONALIZED + 1); // put in cache - cgData.saveCache(main, EnumSet.of(SaveFlag.SAVE_CACHE)); - cgData.saveCache(inTileLowZoom, EnumSet.of(SaveFlag.SAVE_CACHE)); - cgData.saveCache(inTileHighZoom, EnumSet.of(SaveFlag.SAVE_CACHE)); - cgData.saveCache(outTile, EnumSet.of(SaveFlag.SAVE_CACHE)); - cgData.saveCache(otherConnector, EnumSet.of(SaveFlag.SAVE_CACHE)); + DataStore.saveCache(main, EnumSet.of(SaveFlag.SAVE_CACHE)); + DataStore.saveCache(inTileLowZoom, EnumSet.of(SaveFlag.SAVE_CACHE)); + DataStore.saveCache(inTileHighZoom, EnumSet.of(SaveFlag.SAVE_CACHE)); + DataStore.saveCache(outTile, EnumSet.of(SaveFlag.SAVE_CACHE)); + DataStore.saveCache(otherConnector, EnumSet.of(SaveFlag.SAVE_CACHE)); final SearchResult search = new SearchResult(main); - Set<String> filteredGeoCodes = cgData.getCachedMissingFromSearch(search, tiles, GCConnector.getInstance(), Tile.ZOOMLEVEL_MIN_PERSONALIZED - 1); + Set<String> filteredGeoCodes = DataStore.getCachedMissingFromSearch(search, tiles, GCConnector.getInstance(), Tile.ZOOMLEVEL_MIN_PERSONALIZED - 1); assertTrue(filteredGeoCodes.contains(inTileLowZoom.getGeocode())); assertFalse(filteredGeoCodes.contains(inTileHighZoom.getGeocode())); diff --git a/tests/src/cgeo/geocaching/GeocacheTest.java b/tests/src/cgeo/geocaching/GeocacheTest.java index 4c09594..e1c0769 100644 --- a/tests/src/cgeo/geocaching/GeocacheTest.java +++ b/tests/src/cgeo/geocaching/GeocacheTest.java @@ -1,16 +1,14 @@ package cgeo.geocaching; +import cgeo.CGeoTestCase; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.geopoint.Geopoint; -import android.os.Handler; -import android.test.AndroidTestCase; - import java.util.ArrayList; import java.util.Date; import java.util.List; -public class GeocacheTest extends AndroidTestCase { +public class GeocacheTest extends CGeoTestCase { final static private class MockedEventCache extends Geocache { public MockedEventCache(final Date date) { @@ -52,31 +50,41 @@ public class GeocacheTest extends AndroidTestCase { assertEquals("GC1234", cache.getGeocode()); } - public static void testUpdateWaypointFromNote() { + public void testUpdateWaypointFromNote() { assertWaypointsParsed("Test N51 13.888 E007 03.444", 1); } - public static void testUpdateWaypointsFromNote() { + public void testUpdateWaypointsFromNote() { assertWaypointsParsed("Test N51 13.888 E007 03.444 Test N51 13.233 E007 03.444 Test N51 09.123 E007 03.444", 3); } - private static void assertWaypointsParsed(String note, int expectedWaypoints) { - Geocache cache = new Geocache(); - cache.setGeocode("Test" + System.nanoTime()); - cache.setWaypoints(new ArrayList<Waypoint>(), false); - for (int i = 0; i < 2; i++) { - cache.setPersonalNote(note); - cache.parseWaypointsFromNote(); - final List<Waypoint> waypoints = cache.getWaypoints(); - assertNotNull(waypoints); - assertEquals(expectedWaypoints, waypoints.size()); - final Waypoint waypoint = waypoints.get(0); - assertEquals(new Geopoint("N51 13.888 E007 03.444"), waypoint.getCoords()); - // assertEquals("Test", waypoint.getNote()); - assertEquals(cgeoapplication.getInstance().getString(R.string.cache_personal_note) + " 1", waypoint.getName()); - cache.store(StoredList.TEMPORARY_LIST_ID, null); + private void assertWaypointsParsed(String note, int expectedWaypoints) { + + recordMapStoreFlags(); + + try { + setMapStoreFlags(false, false); + + Geocache cache = new Geocache(); + final String geocode = "Test" + System.nanoTime(); + cache.setGeocode(geocode); + cache.setWaypoints(new ArrayList<Waypoint>(), false); + for (int i = 0; i < 2; i++) { + cache.setPersonalNote(note); + cache.parseWaypointsFromNote(); + final List<Waypoint> waypoints = cache.getWaypoints(); + assertNotNull(waypoints); + assertEquals(expectedWaypoints, waypoints.size()); + final Waypoint waypoint = waypoints.get(0); + assertEquals(new Geopoint("N51 13.888 E007 03.444"), waypoint.getCoords()); + // assertEquals("Test", waypoint.getNote()); + assertEquals(CgeoApplication.getInstance().getString(R.string.cache_personal_note) + " 1", waypoint.getName()); + cache.store(StoredList.TEMPORARY_LIST_ID, null); + } + removeCacheCompletely(geocode); + } finally { + restoreMapStoreFlags(); } - cache.drop(new Handler()); } public static void testMergeDownloadedStored() { diff --git a/tests/src/cgeo/geocaching/StoredListTest.java b/tests/src/cgeo/geocaching/StoredListTest.java index dd8b6c7..ce7c963 100644 --- a/tests/src/cgeo/geocaching/StoredListTest.java +++ b/tests/src/cgeo/geocaching/StoredListTest.java @@ -5,13 +5,13 @@ import junit.framework.TestCase; public class StoredListTest extends TestCase { public static void testStandardListExists() { - final StoredList list = cgData.getList(StoredList.STANDARD_LIST_ID); + final StoredList list = DataStore.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); + final StoredList list1 = DataStore.getList(StoredList.STANDARD_LIST_ID); + final StoredList list2 = DataStore.getList(StoredList.STANDARD_LIST_ID); assertEquals(list1, list2); } diff --git a/tests/src/cgeo/geocaching/cgeoApplicationTest.java b/tests/src/cgeo/geocaching/cgeoApplicationTest.java index 83bf28d..4f45cc5 100644 --- a/tests/src/cgeo/geocaching/cgeoApplicationTest.java +++ b/tests/src/cgeo/geocaching/cgeoApplicationTest.java @@ -111,7 +111,7 @@ public class cgeoApplicationTest extends CGeoTestCase { if (Settings.isPremiumMember() || search.getError() == null) { assertEquals(1, search.getGeocodes().size()); assertTrue(search.getGeocodes().contains(geocode)); - return cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); + return DataStore.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); } assertEquals(0, search.getGeocodes().size()); return null; @@ -295,7 +295,7 @@ public class cgeoApplicationTest extends CGeoTestCase { 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); + Geocache parsedCache = DataStore.loadCache(mockedCache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB); assertEquals(Settings.isPremiumMember(), mockedCache.getCoords().equals(parsedCache.getCoords())); assertEquals(Settings.isPremiumMember(), parsedCache.isReliableLatLon()); @@ -307,7 +307,7 @@ public class cgeoApplicationTest extends CGeoTestCase { search = ConnectorFactory.searchByViewport(viewport, tokens); assertNotNull(search); assertTrue(search.getGeocodes().contains(mockedCache.getGeocode())); - parsedCache = cgData.loadCache(mockedCache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB); + parsedCache = DataStore.loadCache(mockedCache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB); assertEquals(Settings.isPremiumMember(), mockedCache.getCoords().equals(parsedCache.getCoords())); assertEquals(Settings.isPremiumMember(), parsedCache.isReliableLatLon()); @@ -350,7 +350,7 @@ public class cgeoApplicationTest extends CGeoTestCase { assertNotNull(search); assertTrue(search.getGeocodes().contains(cache.getGeocode())); // coords differ - final Geocache cacheFromViewport = cgData.loadCache(cache.getGeocode(), LoadFlags.LOAD_CACHE_OR_DB); + final Geocache cacheFromViewport = DataStore.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)); diff --git a/tests/src/cgeo/geocaching/connector/gc/GCParserTest.java b/tests/src/cgeo/geocaching/connector/gc/GCParserTest.java index de52171..dacbba6 100644 --- a/tests/src/cgeo/geocaching/connector/gc/GCParserTest.java +++ b/tests/src/cgeo/geocaching/connector/gc/GCParserTest.java @@ -1,11 +1,11 @@ package cgeo.geocaching.connector.gc; +import cgeo.geocaching.CgeoApplication; import cgeo.geocaching.Geocache; import cgeo.geocaching.Image; import cgeo.geocaching.SearchResult; import cgeo.geocaching.Trackable; import cgeo.geocaching.Waypoint; -import cgeo.geocaching.cgeoapplication; import cgeo.geocaching.enumerations.LoadFlags; import cgeo.geocaching.enumerations.StatusCode; import cgeo.geocaching.enumerations.WaypointType; @@ -220,7 +220,7 @@ public class GCParserTest extends AbstractResourceInstrumentationTestCase { final Trackable trackable = GCParser.parseTrackable(page, "TB123E"); assertNotNull(trackable); assertEquals("TB123E", trackable.getGeocode()); - final String expectedDetails = cgeoapplication.getInstance().getString(cgeo.geocaching.R.string.trackable_not_activated); + final String expectedDetails = CgeoApplication.getInstance().getString(cgeo.geocaching.R.string.trackable_not_activated); assertEquals(expectedDetails, trackable.getDetails()); } } diff --git a/tests/src/cgeo/geocaching/connector/gc/WaypointsTest.java b/tests/src/cgeo/geocaching/connector/gc/WaypointsTest.java index d186526..19acd7c 100644 --- a/tests/src/cgeo/geocaching/connector/gc/WaypointsTest.java +++ b/tests/src/cgeo/geocaching/connector/gc/WaypointsTest.java @@ -1,9 +1,9 @@ package cgeo.geocaching.connector.gc; import cgeo.CGeoTestCase; +import cgeo.geocaching.DataStore; import cgeo.geocaching.Geocache; import cgeo.geocaching.SearchResult; -import cgeo.geocaching.cgData; import cgeo.geocaching.enumerations.LoadFlags; import cgeo.geocaching.utils.CancellableHandler; @@ -27,7 +27,7 @@ public class WaypointsTest extends CGeoTestCase { 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); + DataStore.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/OCConnectorTest.java b/tests/src/cgeo/geocaching/connector/oc/OCConnectorTest.java new file mode 100644 index 0000000..bbbd710 --- /dev/null +++ b/tests/src/cgeo/geocaching/connector/oc/OCConnectorTest.java @@ -0,0 +1,25 @@ +package cgeo.geocaching.connector.oc; + +import cgeo.geocaching.connector.ConnectorFactory; +import cgeo.geocaching.connector.IConnector; + +import junit.framework.TestCase; + +public class OCConnectorTest extends TestCase { + + /** + * OC.DE used up the 4 digit/character name space and switched over to 5 recently + */ + public static void testCanHandleNew5DigitCodes() { + final IConnector ocConnector = getOcDeConnector(); + assertTrue(ocConnector.canHandle("OCFFFF")); + assertTrue(ocConnector.canHandle("OC10000")); + } + + private static IConnector getOcDeConnector() { + final IConnector ocConnector = ConnectorFactory.getConnector("OCXXX"); + assertTrue(ocConnector.getHost().contains(".de")); + return ocConnector; + } + +} diff --git a/tests/src/cgeo/geocaching/connector/oc/OkapiClientTest.java b/tests/src/cgeo/geocaching/connector/oc/OkapiClientTest.java index 410252f..eb797c2 100644 --- a/tests/src/cgeo/geocaching/connector/oc/OkapiClientTest.java +++ b/tests/src/cgeo/geocaching/connector/oc/OkapiClientTest.java @@ -2,7 +2,7 @@ package cgeo.geocaching.connector.oc; import cgeo.CGeoTestCase; import cgeo.geocaching.Geocache; -import cgeo.geocaching.cgData; +import cgeo.geocaching.DataStore; import cgeo.geocaching.enumerations.LoadFlags; public class OkapiClientTest extends CGeoTestCase { @@ -10,12 +10,12 @@ public class OkapiClientTest extends CGeoTestCase { public static void testGetOCCache() { final String geoCode = "OU0331"; Geocache cache = OkapiClient.getCache(geoCode); - assertNotNull(cache); - assertEquals(geoCode, cache.getGeocode()); + assertNotNull("Did not get cache from OKAPI", cache); + assertEquals("Unexpected geo code", 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 = cgData.loadCache(geoCode, LoadFlags.LOAD_ALL_DB_ONLY); + cache = DataStore.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/connector/trackable/GeokretyParserTest.java b/tests/src/cgeo/geocaching/connector/trackable/GeokretyParserTest.java index 3915993..8f21342 100644 --- a/tests/src/cgeo/geocaching/connector/trackable/GeokretyParserTest.java +++ b/tests/src/cgeo/geocaching/connector/trackable/GeokretyParserTest.java @@ -1,7 +1,7 @@ package cgeo.geocaching.connector.trackable; +import cgeo.geocaching.CgeoApplication; import cgeo.geocaching.Trackable; -import cgeo.geocaching.cgeoapplication; import cgeo.geocaching.test.AbstractResourceInstrumentationTestCase; import cgeo.geocaching.test.R; @@ -13,7 +13,7 @@ public class GeokretyParserTest extends AbstractResourceInstrumentationTestCase assertEquals("WeltenbummlerKret", trackable.getName()); assertEquals("GK008D", trackable.getGeocode()); assertEquals(2235f, trackable.getDistance()); - assertEquals(cgeoapplication.getInstance().getString(cgeo.geocaching.R.string.geokret_type_traditional), trackable.getType()); + assertEquals(CgeoApplication.getInstance().getString(cgeo.geocaching.R.string.geokret_type_traditional), trackable.getType()); } } diff --git a/tests/src/cgeo/geocaching/export/ExportTest.java b/tests/src/cgeo/geocaching/export/ExportTest.java index 3e5505a..6d39f8d 100644 --- a/tests/src/cgeo/geocaching/export/ExportTest.java +++ b/tests/src/cgeo/geocaching/export/ExportTest.java @@ -1,9 +1,9 @@ package cgeo.geocaching.export; import cgeo.CGeoTestCase; +import cgeo.geocaching.DataStore; import cgeo.geocaching.Geocache; import cgeo.geocaching.LogEntry; -import cgeo.geocaching.cgData; import cgeo.geocaching.enumerations.LoadFlags; import cgeo.geocaching.enumerations.LogType; import cgeo.geocaching.geopoint.Geopoint; @@ -30,7 +30,7 @@ public class ExportTest extends CGeoTestCase { cache.setCoords(new Geopoint("N 49 44.000 E 8 37.000")); final LogEntry log = new LogEntry(1353244820000L, LogType.FOUND_IT, "Smile: \ud83d\ude0a"); cache.getLogs().add(log); - cgData.saveCache(cache, LoadFlags.SAVE_ALL); + DataStore.saveCache(cache, LoadFlags.SAVE_ALL); ArrayList<Geocache> exportList = new ArrayList<Geocache>(); exportList.add(cache); GpxExportTester gpxExport = new GpxExportTester(); @@ -38,7 +38,7 @@ public class ExportTest extends CGeoTestCase { try { result = gpxExport.testExportSync(exportList); } finally { - cgData.removeCache(cache.getGeocode(), LoadFlags.REMOVE_ALL); + DataStore.removeCache(cache.getGeocode(), LoadFlags.REMOVE_ALL); } assertNotNull(result); diff --git a/tests/src/cgeo/geocaching/export/GpxSerializerTest.java b/tests/src/cgeo/geocaching/export/GpxSerializerTest.java index 0080b76..ad1cea0 100644 --- a/tests/src/cgeo/geocaching/export/GpxSerializerTest.java +++ b/tests/src/cgeo/geocaching/export/GpxSerializerTest.java @@ -1,12 +1,19 @@ package cgeo.geocaching.export; import cgeo.geocaching.Geocache; +import cgeo.geocaching.StoredList; +import cgeo.geocaching.files.GPX10Parser; import cgeo.geocaching.files.ParserException; import cgeo.geocaching.test.AbstractResourceInstrumentationTestCase; import cgeo.geocaching.test.R; +import org.apache.commons.lang3.CharEncoding; + +import java.io.ByteArrayInputStream; import java.io.IOException; +import java.io.InputStream; import java.io.StringWriter; +import java.util.Collection; import java.util.Collections; import java.util.concurrent.atomic.AtomicReference; @@ -34,4 +41,42 @@ public class GpxSerializerTest extends AbstractResourceInstrumentationTestCase { }); assertEquals("Progress listener not called", 1, importedCount.get().intValue()); } + + /** + * This test verifies that a loop of import, export, import leads to the same cache information. + * + * @throws IOException + * @throws ParserException + */ + public void testStableExportImportExport() throws IOException, ParserException { + final String geocode = "GC1BKP3"; + final int cacheResource = R.raw.gc1bkp3_gpx101; + final Geocache cache = loadCacheFromResource(cacheResource); + assertNotNull(cache); + + final String gpxFirst = getGPXFromCache(geocode); + + assertTrue(gpxFirst.length() > 0); + + final GPX10Parser parser = new GPX10Parser(StoredList.TEMPORARY_LIST_ID); + + final InputStream stream = new ByteArrayInputStream(gpxFirst.getBytes(CharEncoding.UTF_8)); + Collection<Geocache> caches = parser.parse(stream, null); + assertNotNull(caches); + assertEquals(1, caches.size()); + + final String gpxSecond = getGPXFromCache(geocode); + assertEquals(replaceLogIds(gpxFirst), replaceLogIds(gpxSecond)); + } + + private static String replaceLogIds(String gpx) { + return gpx.replaceAll("log id=\"\\d*\"", ""); + } + + private static String getGPXFromCache(String geocode) throws IOException { + final StringWriter writer = new StringWriter(); + new GpxSerializer().writeGPX(Collections.singletonList(geocode), writer, null); + return writer.toString(); + } + } diff --git a/tests/src/cgeo/geocaching/files/GPXImporterTest.java b/tests/src/cgeo/geocaching/files/GPXImporterTest.java index 03f917c..8f5d821 100644 --- a/tests/src/cgeo/geocaching/files/GPXImporterTest.java +++ b/tests/src/cgeo/geocaching/files/GPXImporterTest.java @@ -1,8 +1,8 @@ package cgeo.geocaching.files; +import cgeo.geocaching.DataStore; import cgeo.geocaching.Geocache; import cgeo.geocaching.SearchResult; -import cgeo.geocaching.cgData; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.enumerations.LoadFlags; import cgeo.geocaching.settings.Settings; @@ -74,7 +74,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { assertEquals(GPXImporter.IMPORT_STEP_FINISHED, iMsg.next().what); final SearchResult search = (SearchResult) importStepHandler.messages.get(3).obj; assertEquals(Collections.singletonList(geocode), new ArrayList<String>(search.getGeocodes())); - final Geocache cache = cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); + final Geocache cache = DataStore.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); assertTrue(cache.getWaypoints().isEmpty()); @@ -101,7 +101,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_READ_WPT_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED); final SearchResult search = (SearchResult) importStepHandler.messages.get(4).obj; assertEquals(Collections.singletonList("GC31J2H"), new ArrayList<String>(search.getGeocodes())); - final Geocache cache = cgData.loadCache("GC31J2H", LoadFlags.LOAD_CACHE_OR_DB); + final Geocache cache = DataStore.loadCache("GC31J2H", LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); assertEquals(2, cache.getWaypoints().size()); } @@ -114,7 +114,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 Geocache cache = cgData.loadCache("AID1", LoadFlags.LOAD_CACHE_OR_DB); + final Geocache cache = DataStore.loadCache("AID1", LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); assertEquals("First Aid Station #1", cache.getName()); } @@ -136,7 +136,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED); final SearchResult search = (SearchResult) importStepHandler.messages.get(3).obj; assertEquals(Collections.singletonList("OC5952"), new ArrayList<String>(search.getGeocodes())); - final Geocache cache = cgData.loadCache("OC5952", LoadFlags.LOAD_CACHE_OR_DB); + final Geocache cache = DataStore.loadCache("OC5952", LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); } @@ -178,7 +178,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED); final SearchResult search = (SearchResult) importStepHandler.messages.get(3).obj; assertEquals(Collections.singletonList(geocode), new ArrayList<String>(search.getGeocodes())); - final Geocache cache = cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); + final Geocache cache = DataStore.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); assertTrue(cache.getWaypoints().isEmpty()); @@ -196,7 +196,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_READ_WPT_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED); final SearchResult search = (SearchResult) importStepHandler.messages.get(4).obj; assertEquals(Collections.singletonList(geocode), new ArrayList<String>(search.getGeocodes())); - final Geocache cache = cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); + final Geocache cache = DataStore.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); assertEquals(1, cache.getWaypoints().size()); // this is the original pocket query result without test waypoint } @@ -222,7 +222,7 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { assertImportStepMessages(GPXImporter.IMPORT_STEP_START, GPXImporter.IMPORT_STEP_READ_FILE, GPXImporter.IMPORT_STEP_READ_WPT_FILE, GPXImporter.IMPORT_STEP_STORE_STATIC_MAPS, GPXImporter.IMPORT_STEP_FINISHED); final SearchResult search = (SearchResult) importStepHandler.messages.get(4).obj; assertEquals(Collections.singletonList(geocode), new ArrayList<String>(search.getGeocodes())); - final Geocache cache = cgData.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); + final Geocache cache = DataStore.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB); assertCacheProperties(cache); assertEquals(1, cache.getWaypoints().size()); // this is the original pocket query result without test waypoint } @@ -267,8 +267,8 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { tempDir.mkdir(); assertTrue("Could not create directory " + tempDir.getPath(), tempDir.exists()); // workaround to get storage initialized - cgData.getAllHistoryCachesCount(); - listId = cgData.createList("cgeogpxesTest"); + DataStore.getAllHistoryCachesCount(); + listId = DataStore.createList("cgeogpxesTest"); importCacheStaticMaps = Settings.isStoreOfflineMaps(); TestSettings.setStoreOfflineMaps(true); @@ -278,11 +278,11 @@ public class GPXImporterTest extends AbstractResourceInstrumentationTestCase { @Override protected void tearDown() throws Exception { - final SearchResult search = cgData.getBatchOfStoredCaches(null, CacheType.ALL, listId); + final SearchResult search = DataStore.getBatchOfStoredCaches(null, CacheType.ALL, listId); final List<Geocache> cachesInList = new ArrayList<Geocache>(); cachesInList.addAll(search.getCachesFromSearchResult(LoadFlags.LOAD_CACHE_OR_DB)); - cgData.markDropped(cachesInList); - cgData.removeList(listId); + DataStore.markDropped(cachesInList); + DataStore.removeList(listId); deleteDirectory(tempDir); TestSettings.setStoreOfflineMaps(importCacheStaticMaps); TestSettings.setStoreOfflineWpMaps(importWpStaticMaps); diff --git a/tests/src/cgeo/geocaching/files/GPXParserTest.java b/tests/src/cgeo/geocaching/files/GPXParserTest.java index 892b2a0..9604519 100644 --- a/tests/src/cgeo/geocaching/files/GPXParserTest.java +++ b/tests/src/cgeo/geocaching/files/GPXParserTest.java @@ -1,9 +1,9 @@ package cgeo.geocaching.files; +import cgeo.geocaching.DataStore; import cgeo.geocaching.Geocache; import cgeo.geocaching.LogEntry; import cgeo.geocaching.Waypoint; -import cgeo.geocaching.cgData; import cgeo.geocaching.enumerations.CacheSize; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.enumerations.LoadFlags; @@ -150,6 +150,9 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { assertEquals(parseTime("2011-09-11T07:00:00Z"), log.date); assertEquals(-1, log.found); assertEquals("Sehr schöne Runde und wir haben wieder etwas Neues über Hockenheim gelernt. Super Tarnung.\nTFTC, Geoteufel", log.log); + assertFalse(log.isOwn()); + assertEquals(log.log, log.getDisplayText()); + assertTrue(log.daysSinceLog() > 700); // following info is not contained in pocket query gpx file assertEquals(0, cache.getAttributes().size()); @@ -212,7 +215,7 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { } } // reload caches, because the parser only returns the minimum version of each cache - return new ArrayList<Geocache>(cgData.loadCaches(result, LoadFlags.LOAD_ALL_DB_ONLY)); + return new ArrayList<Geocache>(DataStore.loadCaches(result, LoadFlags.LOAD_ALL_DB_ONLY)); } public static void testParseDateWithFractionalSeconds() throws ParseException { @@ -255,9 +258,9 @@ public class GPXParserTest extends AbstractResourceInstrumentationTestCase { removeCacheCompletely(geocode); final List<Geocache> caches = readGPX10(R.raw.lazy); assertEquals(1, caches.size()); - cgData.removeAllFromCache(); + DataStore.removeAllFromCache(); // load only the minimum cache, it has several members missing - final Geocache minimalCache = cgData.loadCache(geocode, EnumSet.of(LoadFlag.LOAD_DB_MINIMAL)); + final Geocache minimalCache = DataStore.loadCache(geocode, EnumSet.of(LoadFlag.LOAD_DB_MINIMAL)); // now check that we load lazy members on demand assertFalse(minimalCache.getAttributes().isEmpty()); diff --git a/tests/src/cgeo/geocaching/speech/TextFactoryTest.java b/tests/src/cgeo/geocaching/speech/TextFactoryTest.java index 864757b..ec8e1b0 100644 --- a/tests/src/cgeo/geocaching/speech/TextFactoryTest.java +++ b/tests/src/cgeo/geocaching/speech/TextFactoryTest.java @@ -1,6 +1,6 @@ package cgeo.geocaching.speech; -import cgeo.geocaching.cgeoapplication; +import cgeo.geocaching.CgeoApplication; import cgeo.geocaching.geopoint.Geopoint; import cgeo.geocaching.settings.Settings; import cgeo.geocaching.settings.TestSettings; @@ -29,7 +29,7 @@ public class TextFactoryTest extends AndroidTestCase { @Override protected void setUp() throws Exception { super.setUp(); - final Resources resources = cgeoapplication.getInstance().getResources(); + final Resources resources = CgeoApplication.getInstance().getResources(); final Configuration config = resources.getConfiguration(); defaultLocale1 = config.locale; defaultLocale2 = Locale.getDefault(); @@ -149,7 +149,7 @@ public class TextFactoryTest extends AndroidTestCase { private static void setLocale(Locale locale1, Locale locale2, boolean metric) { final Configuration config = new Configuration(); config.locale = locale1; - final Resources resources = cgeoapplication.getInstance().getResources(); + final Resources resources = CgeoApplication.getInstance().getResources(); resources.updateConfiguration(config, resources.getDisplayMetrics()); Locale.setDefault(locale2); diff --git a/tests/src/cgeo/geocaching/test/AbstractResourceInstrumentationTestCase.java b/tests/src/cgeo/geocaching/test/AbstractResourceInstrumentationTestCase.java index cb8238f..bb03274 100644 --- a/tests/src/cgeo/geocaching/test/AbstractResourceInstrumentationTestCase.java +++ b/tests/src/cgeo/geocaching/test/AbstractResourceInstrumentationTestCase.java @@ -1,9 +1,9 @@ package cgeo.geocaching.test; +import cgeo.geocaching.DataStore; import cgeo.geocaching.Geocache; import cgeo.geocaching.SearchResult; import cgeo.geocaching.StoredList; -import cgeo.geocaching.cgData; import cgeo.geocaching.enumerations.CacheType; import cgeo.geocaching.enumerations.LoadFlags; import cgeo.geocaching.enumerations.LoadFlags.RemoveFlag; @@ -27,7 +27,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); - cgData.removeCache(geocode, flags); + DataStore.removeCache(geocode, flags); } protected InputStream getResourceStream(int resourceId) { @@ -65,17 +65,17 @@ public abstract class AbstractResourceInstrumentationTestCase extends Instrument @Override protected void setUp() throws Exception { super.setUp(); - temporaryListId = cgData.createList("Temporary unit testing"); + temporaryListId = DataStore.createList("Temporary unit testing"); assertTrue(temporaryListId != StoredList.TEMPORARY_LIST_ID); assertTrue(temporaryListId != StoredList.STANDARD_LIST_ID); } @Override protected void tearDown() throws Exception { - final SearchResult search = cgData.getBatchOfStoredCaches(null, CacheType.ALL, temporaryListId); + final SearchResult search = DataStore.getBatchOfStoredCaches(null, CacheType.ALL, temporaryListId); assertNotNull(search); - cgData.removeCaches(search.getGeocodes(), LoadFlags.REMOVE_ALL); - cgData.removeList(temporaryListId); + DataStore.removeCaches(search.getGeocodes(), LoadFlags.REMOVE_ALL); + DataStore.removeList(temporaryListId); super.tearDown(); } diff --git a/tests/src/cgeo/geocaching/ui/FormatterTest.java b/tests/src/cgeo/geocaching/ui/FormatterTest.java index e65f425..53aba0f 100644 --- a/tests/src/cgeo/geocaching/ui/FormatterTest.java +++ b/tests/src/cgeo/geocaching/ui/FormatterTest.java @@ -2,7 +2,7 @@ package cgeo.geocaching.ui; import cgeo.geocaching.R; import cgeo.geocaching.Waypoint; -import cgeo.geocaching.cgeoapplication; +import cgeo.geocaching.CgeoApplication; import cgeo.geocaching.enumerations.WaypointType; import android.test.AndroidTestCase; @@ -20,7 +20,7 @@ public class FormatterTest extends AndroidTestCase { 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)); + assertFormatting(own, CgeoApplication.getInstance().getString(R.string.waypoint_custom)); } private static void assertFormatting(Waypoint waypoint, String expected) { diff --git a/tests/src/cgeo/geocaching/utils/CryptUtilsTest.java b/tests/src/cgeo/geocaching/utils/CryptUtilsTest.java index e727747..9264d29 100644 --- a/tests/src/cgeo/geocaching/utils/CryptUtilsTest.java +++ b/tests/src/cgeo/geocaching/utils/CryptUtilsTest.java @@ -23,4 +23,16 @@ public class CryptUtilsTest extends TestCase { public static void testIssue1902() { assertEquals("ƖƖlƖƖƖƖ", CryptUtils.rot13("ƖƖyƖƖƖƖ")); } + + public static void testSha1() { + assertEquals("da39a3ee5e6b4b0d3255bfef95601890afd80709", CryptUtils.sha1("")); + // expected value taken from debugger. should assure every developer uses UTF-8 + assertEquals("cf2f343f59cea81afc0a5a566cb138ba349c548f", CryptUtils.sha1("äöü")); + } + + public static void testMd5() { + assertEquals("d41d8cd98f00b204e9800998ecf8427e", CryptUtils.md5("")); + // expected value taken from debugger. should assure every developer uses UTF-8 + assertEquals("a7f4e3ec08f09be2ef7ecb4eea5f8981", CryptUtils.md5("äöü")); + } } diff --git a/tests/src/cgeo/geocaching/utils/UncertainPropertyTest.java b/tests/src/cgeo/geocaching/utils/UncertainPropertyTest.java new file mode 100644 index 0000000..74aa680 --- /dev/null +++ b/tests/src/cgeo/geocaching/utils/UncertainPropertyTest.java @@ -0,0 +1,19 @@ +package cgeo.geocaching.utils; + +import junit.framework.TestCase; + +public class UncertainPropertyTest extends TestCase { + + public static void testHigherCertaintyWins() throws Exception { + final UncertainProperty<String> prop1 = new UncertainProperty<String>("prop1", 10); + final UncertainProperty<String> prop2 = new UncertainProperty<String>("prop2", 20); + assertEquals(prop2, UncertainProperty.getMergedProperty(prop1, prop2)); + } + + public static void testAvoidNull() throws Exception { + final UncertainProperty<String> prop1 = new UncertainProperty<String>("prop1", 10); + final UncertainProperty<String> prop2 = new UncertainProperty<String>(null, 20); + assertEquals(prop1, UncertainProperty.getMergedProperty(prop1, prop2)); + assertEquals(prop1, UncertainProperty.getMergedProperty(prop2, prop1)); + } +} diff --git a/tests/src/cgeo/geocaching/utils/XmlUtilsTest.java b/tests/src/cgeo/geocaching/utils/XmlUtilsTest.java new file mode 100644 index 0000000..a089ee0 --- /dev/null +++ b/tests/src/cgeo/geocaching/utils/XmlUtilsTest.java @@ -0,0 +1,48 @@ +package cgeo.geocaching.utils; + +import cgeo.org.kxml2.io.KXmlSerializer; + +import org.apache.commons.lang3.CharEncoding; +import org.xmlpull.v1.XmlSerializer; + +import java.io.IOException; +import java.io.StringWriter; + +import junit.framework.TestCase; + +public class XmlUtilsTest extends TestCase { + + private XmlSerializer xml; + private StringWriter stringWriter; + + @Override + protected void setUp() throws Exception { + super.setUp(); + stringWriter = new StringWriter(); + xml = new KXmlSerializer(); + xml.setOutput(stringWriter); + xml.startDocument(CharEncoding.UTF_8, null); + } + + public void testSimpleText() throws Exception { + XmlUtils.simpleText(xml, "", "tag", "text"); + assertXmlEquals("<tag>text</tag>"); + } + + public void testSimpleTextWithPrefix() throws Exception { + XmlUtils.simpleText(xml, "prefix", "tag", "text"); + assertXmlEquals("<n0:tag xmlns:n0=\"prefix\">text</n0:tag>"); + } + + private void assertXmlEquals(final String expected) throws IOException { + xml.endDocument(); + xml.flush(); + assertEquals("<?xml version='1.0' encoding='UTF-8' ?>" + expected, stringWriter.toString()); + } + + public void testMultipleTexts() throws Exception { + XmlUtils.multipleTexts(xml, "", "tag1", "text1", "tag2", "text2"); + assertXmlEquals("<tag1>text1</tag1><tag2>text2</tag2>"); + } + +} |