diff options
13 files changed, 266 insertions, 27 deletions
diff --git a/main/src/cgeo/geocaching/cgCache.java b/main/src/cgeo/geocaching/cgCache.java index beffa85..52a02de 100644 --- a/main/src/cgeo/geocaching/cgCache.java +++ b/main/src/cgeo/geocaching/cgCache.java @@ -1414,8 +1414,8 @@ public class cgCache implements ICache, IWaypoint { if (!(obj instanceof cgCache)) { return false; } - // just compare the geocode even if that is not what "equals" normaly does - return geocode != null ? geocode.compareTo(((cgCache) obj).geocode) == 0 : false; + // just compare the geocode even if that is not what "equals" normally does + return StringUtils.isNotBlank(geocode) ? geocode.equals(((cgCache) obj).geocode) : false; } public void store(Activity activity, CancellableHandler handler) { diff --git a/main/src/cgeo/geocaching/enumerations/CacheType.java b/main/src/cgeo/geocaching/enumerations/CacheType.java index 96e7eb5..5ea1093 100644 --- a/main/src/cgeo/geocaching/enumerations/CacheType.java +++ b/main/src/cgeo/geocaching/enumerations/CacheType.java @@ -63,7 +63,7 @@ public enum CacheType { } public final static CacheType getById(final String id) { - final CacheType result = id != null ? CacheType.FIND_BY_ID.get(id.toLowerCase().trim()) : null; + final CacheType result = (id != null) ? CacheType.FIND_BY_ID.get(id.toLowerCase().trim()) : null; if (result == null) { return UNKNOWN; } @@ -71,7 +71,7 @@ public enum CacheType { } public final static CacheType getByPattern(final String pattern) { - final CacheType result = pattern != null ? CacheType.FIND_BY_PATTERN.get(pattern.toLowerCase().trim()) : null; + final CacheType result = (pattern != null) ? CacheType.FIND_BY_PATTERN.get(pattern.toLowerCase().trim()) : null; if (result == null) { return UNKNOWN; } diff --git a/main/src/cgeo/geocaching/filter/SizeFilter.java b/main/src/cgeo/geocaching/filter/SizeFilter.java index 4f0d830..ecbbd95 100644 --- a/main/src/cgeo/geocaching/filter/SizeFilter.java +++ b/main/src/cgeo/geocaching/filter/SizeFilter.java @@ -25,7 +25,7 @@ public class SizeFilter extends AbstractFilter { public static AbstractFilter[] getAllFilters() { final CacheSize[] cacheSizes = CacheSize.values(); - ArrayList<SizeFilter> filters = new ArrayList<SizeFilter>(); + final ArrayList<SizeFilter> filters = new ArrayList<SizeFilter>(); for (CacheSize cacheSize : cacheSizes) { if (cacheSize != CacheSize.UNKNOWN) { filters.add(new SizeFilter(cacheSize)); diff --git a/main/src/cgeo/geocaching/filter/StateFilter.java b/main/src/cgeo/geocaching/filter/StateFilter.java index 454cc92..93e8c66 100644 --- a/main/src/cgeo/geocaching/filter/StateFilter.java +++ b/main/src/cgeo/geocaching/filter/StateFilter.java @@ -12,14 +12,16 @@ import java.util.Comparator; public abstract class StateFilter extends AbstractFilter { - public StateFilter(String name) { + final static Resources res = cgeoapplication.getInstance().getResources(); + + protected StateFilter(String name) { super(name); } - private static class StateFoundFilter extends StateFilter { + static class StateFoundFilter extends StateFilter { - public StateFoundFilter(String name) { - super(name); + public StateFoundFilter() { + super(res.getString(R.string.cache_status_found)); } @Override @@ -29,9 +31,9 @@ public abstract class StateFilter extends AbstractFilter { } - private static class StateArchivedFilter extends StateFilter { - public StateArchivedFilter(String name) { - super(name); + static class StateArchivedFilter extends StateFilter { + public StateArchivedFilter() { + super(res.getString(R.string.cache_status_archived)); } @Override @@ -40,9 +42,9 @@ public abstract class StateFilter extends AbstractFilter { } } - private static class StateDisabledFilter extends StateFilter { - public StateDisabledFilter(String name) { - super(name); + static class StateDisabledFilter extends StateFilter { + public StateDisabledFilter() { + super(res.getString(R.string.cache_status_disabled)); } @Override @@ -51,9 +53,9 @@ public abstract class StateFilter extends AbstractFilter { } } - private static class StatePremiumFilter extends StateFilter { - public StatePremiumFilter(String name) { - super(name); + static class StatePremiumFilter extends StateFilter { + public StatePremiumFilter() { + super(res.getString(R.string.cache_status_premium)); } @Override @@ -63,8 +65,8 @@ public abstract class StateFilter extends AbstractFilter { } private static class StateOfflineLogFilter extends StateFilter { - public StateOfflineLogFilter(String name) { - super(name); + public StateOfflineLogFilter() { + super(res.getString(R.string.cache_status_offline_log)); } @Override @@ -74,13 +76,12 @@ public abstract class StateFilter extends AbstractFilter { } public static AbstractFilter[] getAllFilters() { - final Resources res = cgeoapplication.getInstance().getResources(); final ArrayList<StateFilter> filters = new ArrayList<StateFilter>(); - filters.add(new StateFoundFilter(res.getString(R.string.cache_status_found))); - filters.add(new StateArchivedFilter(res.getString(R.string.cache_status_archived))); - filters.add(new StateDisabledFilter(res.getString(R.string.cache_status_disabled))); - filters.add(new StatePremiumFilter(res.getString(R.string.cache_status_premium))); - filters.add(new StateOfflineLogFilter(res.getString(R.string.cache_status_offline_log))); + filters.add(new StateFoundFilter()); + filters.add(new StateArchivedFilter()); + filters.add(new StateDisabledFilter()); + filters.add(new StatePremiumFilter()); + filters.add(new StateOfflineLogFilter()); Collections.sort(filters, new Comparator<StateFilter>() { diff --git a/main/src/cgeo/geocaching/filter/TypeFilter.java b/main/src/cgeo/geocaching/filter/TypeFilter.java index bb32fdd..cfeb007 100644 --- a/main/src/cgeo/geocaching/filter/TypeFilter.java +++ b/main/src/cgeo/geocaching/filter/TypeFilter.java @@ -25,7 +25,7 @@ public class TypeFilter extends AbstractFilter { public static IFilter[] getAllFilters() { final CacheType[] types = CacheType.values(); - ArrayList<IFilter> filters = new ArrayList<IFilter>(types.length); + final ArrayList<IFilter> filters = new ArrayList<IFilter>(types.length); for (CacheType cacheType : types) { if (cacheType != CacheType.ALL) { filters.add(new TypeFilter(cacheType)); diff --git a/tests/src/cgeo/geocaching/CacheTest.java b/tests/src/cgeo/geocaching/CacheTest.java index a76764d..e1d6efb 100644 --- a/tests/src/cgeo/geocaching/CacheTest.java +++ b/tests/src/cgeo/geocaching/CacheTest.java @@ -25,4 +25,20 @@ public class CacheTest extends AndroidTestCase { assertFalse(cacheYesterday.canBeAddedToCalendar()); } + public static void testEquality() { + final cgCache one = new cgCache(); + final cgCache two = new cgCache(); + + // identity + assertTrue(one.equals(one)); + + // different objects without geocode shall not be equal + assertFalse(one.equals(two)); + + one.setGeocode("geocode"); + two.setGeocode("geocode"); + + // different objects with same geocode shall be equal + assertTrue(one.equals(two)); + } } diff --git a/tests/src/cgeo/geocaching/filter/AbstractFilterTestCase.java b/tests/src/cgeo/geocaching/filter/AbstractFilterTestCase.java new file mode 100644 index 0000000..d2aad26 --- /dev/null +++ b/tests/src/cgeo/geocaching/filter/AbstractFilterTestCase.java @@ -0,0 +1,22 @@ +package cgeo.geocaching.filter; + +import cgeo.geocaching.cgBase; +import cgeo.geocaching.cgeoapplication; + +import android.test.ApplicationTestCase; + +public abstract class AbstractFilterTestCase extends ApplicationTestCase<cgeoapplication> { + + public AbstractFilterTestCase() { + super(cgeoapplication.class); + } + + @Override + protected void setUp() throws Exception { + super.setUp(); + + // init environment + createApplication(); + cgBase.initialize(getApplication()); + } +} diff --git a/tests/src/cgeo/geocaching/filter/SizeFilterTest.java b/tests/src/cgeo/geocaching/filter/SizeFilterTest.java new file mode 100644 index 0000000..b62cd56 --- /dev/null +++ b/tests/src/cgeo/geocaching/filter/SizeFilterTest.java @@ -0,0 +1,48 @@ +package cgeo.geocaching.filter; + +import cgeo.geocaching.cgCache; +import cgeo.geocaching.enumerations.CacheSize; + +import java.util.ArrayList; + +public class SizeFilterTest extends AbstractFilterTestCase { + + private cgCache micro; + private cgCache regular; + private SizeFilter microFilter; + + @Override + protected void setUp() throws Exception { + super.setUp(); + + // cache initialization can only be done without errors after application setup + micro = new cgCache(); + micro.setSize(CacheSize.MICRO); + + regular = new cgCache(); + regular.setSize(CacheSize.REGULAR); + + microFilter = new SizeFilter(CacheSize.MICRO); + } + + public void testAccepts() { + assertTrue(microFilter.accepts(micro)); + assertFalse(microFilter.accepts(regular)); + } + + public static void testGetAllFilters() { + final int expectedSizes = CacheSize.values().length - 1; // hide "UNKNOWN" + assertEquals(expectedSizes, SizeFilter.getAllFilters().length); + } + + public void testFilter() { + final ArrayList<cgCache> list = new ArrayList<cgCache>(); + list.add(regular); + list.add(micro); + assertEquals(2, list.size()); + + microFilter.filter(list); + assertEquals(1, list.size()); + } + +} diff --git a/tests/src/cgeo/geocaching/filter/StateArchivedFilterTest.java b/tests/src/cgeo/geocaching/filter/StateArchivedFilterTest.java new file mode 100644 index 0000000..660a596 --- /dev/null +++ b/tests/src/cgeo/geocaching/filter/StateArchivedFilterTest.java @@ -0,0 +1,26 @@ +package cgeo.geocaching.filter; + +import cgeo.geocaching.cgCache; +import cgeo.geocaching.filter.StateFilter.StateArchivedFilter; + +public class StateArchivedFilterTest extends AbstractFilterTestCase { + + private StateFilter.StateArchivedFilter archivedFilter; + private cgCache archivedCache; + + @Override + protected void setUp() throws Exception { + super.setUp(); + + // members can only be setup here, after application is initialized + archivedFilter = new StateArchivedFilter(); + archivedCache = new cgCache(); + archivedCache.setArchived(true); + } + + public void testAccepts() { + assertTrue(archivedFilter.accepts(archivedCache)); + assertFalse(archivedFilter.accepts(new cgCache())); + } + +} diff --git a/tests/src/cgeo/geocaching/filter/StateDisabledFilterTest.java b/tests/src/cgeo/geocaching/filter/StateDisabledFilterTest.java new file mode 100644 index 0000000..7e8a060 --- /dev/null +++ b/tests/src/cgeo/geocaching/filter/StateDisabledFilterTest.java @@ -0,0 +1,25 @@ +package cgeo.geocaching.filter; + +import cgeo.geocaching.cgCache; +import cgeo.geocaching.filter.StateFilter.StateDisabledFilter; + +public class StateDisabledFilterTest extends AbstractFilterTestCase { + + private StateFilter.StateDisabledFilter disabledFilter; + private cgCache disabledCache; + + @Override + protected void setUp() throws Exception { + super.setUp(); + + disabledFilter = new StateDisabledFilter(); + disabledCache = new cgCache(); + disabledCache.setDisabled(true); + } + + public void testAccepts() { + assertTrue(disabledFilter.accepts(disabledCache)); + assertFalse(disabledFilter.accepts(new cgCache())); + } + +} diff --git a/tests/src/cgeo/geocaching/filter/StateFoundFilterTest.java b/tests/src/cgeo/geocaching/filter/StateFoundFilterTest.java new file mode 100644 index 0000000..3f0ffcc --- /dev/null +++ b/tests/src/cgeo/geocaching/filter/StateFoundFilterTest.java @@ -0,0 +1,25 @@ +package cgeo.geocaching.filter; + +import cgeo.geocaching.cgCache; +import cgeo.geocaching.filter.StateFilter.StateFoundFilter; + +public class StateFoundFilterTest extends AbstractFilterTestCase { + + private StateFilter.StateFoundFilter foundFilter; + private cgCache foundCache; + + @Override + protected void setUp() throws Exception { + super.setUp(); + + foundFilter = new StateFoundFilter(); + foundCache = new cgCache(); + foundCache.setFound(true); + } + + public void testAccepts() { + assertTrue(foundFilter.accepts(foundCache)); + assertFalse(foundFilter.accepts(new cgCache())); + } + +} diff --git a/tests/src/cgeo/geocaching/filter/StatePremiumFilterTest.java b/tests/src/cgeo/geocaching/filter/StatePremiumFilterTest.java new file mode 100644 index 0000000..5968424 --- /dev/null +++ b/tests/src/cgeo/geocaching/filter/StatePremiumFilterTest.java @@ -0,0 +1,25 @@ +package cgeo.geocaching.filter; + +import cgeo.geocaching.cgCache; +import cgeo.geocaching.filter.StateFilter.StatePremiumFilter; + +public class StatePremiumFilterTest extends AbstractFilterTestCase { + + private StateFilter.StatePremiumFilter premiumFilter; + private cgCache premiumCache; + + @Override + protected void setUp() throws Exception { + super.setUp(); + + premiumFilter = new StatePremiumFilter(); + premiumCache = new cgCache(); + premiumCache.setPremiumMembersOnly(true); + } + + public void testAccepts() { + assertTrue(premiumFilter.accepts(premiumCache)); + assertFalse(premiumFilter.accepts(new cgCache())); + } + +} diff --git a/tests/src/cgeo/geocaching/filter/TypeFilterTest.java b/tests/src/cgeo/geocaching/filter/TypeFilterTest.java new file mode 100644 index 0000000..9125c72 --- /dev/null +++ b/tests/src/cgeo/geocaching/filter/TypeFilterTest.java @@ -0,0 +1,51 @@ +package cgeo.geocaching.filter; + +import cgeo.geocaching.cgCache; +import cgeo.geocaching.enumerations.CacheType; + +import java.util.ArrayList; + +public class TypeFilterTest extends AbstractFilterTestCase { + + private TypeFilter traditionalFilter; + private cgCache traditional; + private cgCache mystery; + + @Override + protected void setUp() throws Exception { + super.setUp(); + traditionalFilter = new TypeFilter(CacheType.TRADITIONAL); + + traditional = new cgCache(); + traditional.setType(CacheType.TRADITIONAL); + + mystery = new cgCache(); + mystery.setType(CacheType.MYSTERY); + } + + public void testAccepts() { + assertTrue(traditionalFilter.accepts(traditional)); + assertFalse(traditionalFilter.accepts(mystery)); + } + + public void testFilter() { + final ArrayList<cgCache> list = new ArrayList<cgCache>(); + traditionalFilter.filter(list); + assertEquals(0, list.size()); + + list.add(traditional); + list.add(mystery); + assertEquals(2, list.size()); + + traditionalFilter.filter(list); + assertEquals(1, list.size()); + assertTrue(list.contains(traditional)); + + } + + public static void testGetAllFilters() { + final int expectedEntries = CacheType.values().length - 1; // hide "all" + assertEquals(expectedEntries, TypeFilter.getAllFilters().length); + } + +} |