more unit test for cache filters

* also fix cache equality for caches with empty geocodes (as used in
some tests)

8 files changed, 238 insertions, 0 deletions

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);
+    }
+
+}