Ticket #12880: patch-predicates-instanceof-tests.patch

File patch-predicates-instanceof-tests.patch, 9.0 KB (added by michael2402, 10 years ago)

  • src/org/openstreetmap/josm/tools/Predicates.java 

    diff --git a/src/org/openstreetmap/josm/tools/Predicates.java b/src/org/openstreetmap/josm/tools/Predicates.java
index 2c2b528..0e0fba5 100644
    a b public final class Predicates {  
    7979     * Creates a new predicate that checks if elements are exactly of that class.
    8080     * @param <T> The predicate type.
    8181     * @param clazz The class the elements must have.
    82      * @return A predicate.
     82     * @return The new predicate.
     83     * @throws IllegalArgumentException if clazz is null
    8384     */
    8485    public static <T> Predicate<T> isOfClass(final Class<? extends T> clazz) {
     86        CheckParameterUtil.ensureParameterNotNull(clazz, "clazz");
    8587        return new Predicate<T>() {
    8688            @Override
    8789            public boolean evaluate(T obj) {
    … … public final class Predicates {  
    9193    }
    9294
    9395    /**
     96     * Creates a new predicate that checks if the object is of a given class.
     97     * @param <T> The predicate type.
     98     * @param clazz The class objects need to be of.
     99     * @return The new predicate.
     100     * @throws IllegalArgumentException if clazz is null
     101     */
     102    public static <T> Predicate<T> isInstanceOf(final Class<? extends T> clazz) {
     103        CheckParameterUtil.ensureParameterNotNull(clazz, "clazz");
     104        return new Predicate<T>() {
     105            @Override
     106            public boolean evaluate(T o) {
     107                return clazz.isInstance(o);
     108            }
     109        };
     110    }
     111
     112    /**
    94113     * Returns a {@link Predicate} executing {@link Pattern#matcher(CharSequence)} and {@link java.util.regex.Matcher#matches}.
    95114     * @param pattern the pattern
    96115     * @return a {@link Predicate} executing {@link Pattern#matcher(CharSequence)} and {@link java.util.regex.Matcher#matches}
    … … public final class Predicates {  
    189208            }
    190209        };
    191210    }
     211
    192212}

  • new file test/unit/org/openstreetmap/josm/tools/PredicatesTest.java 

    diff --git a/test/unit/org/openstreetmap/josm/tools/PredicatesTest.java b/test/unit/org/openstreetmap/josm/tools/PredicatesTest.java
new file mode 100644
index 0000000..66a7073
    - +  
     1// License: GPL. For details, see LICENSE file.
     2package org.openstreetmap.josm.tools;
     3
     4import static org.junit.Assert.assertFalse;
     5import static org.junit.Assert.assertTrue;
     6
     7import java.util.Arrays;
     8import java.util.Hashtable;
     9import java.util.List;
     10import java.util.Properties;
     11import java.util.regex.Pattern;
     12
     13import org.junit.BeforeClass;
     14import org.junit.Test;
     15import org.openstreetmap.josm.JOSMFixture;
     16import org.openstreetmap.josm.data.osm.Node;
     17import org.openstreetmap.josm.data.osm.OsmPrimitive;
     18
     19/**
     20 * This test tests the {@link Predicate}s created by the {@link Predicates} class.
     21 *
     22 * @author Michael Zangl
     23 * @since xxx
     24 */
     25public class PredicatesTest {
     26    /**
     27     * Not needed by this test, but JOSM has so many dependencies :-(
     28     */
     29    @BeforeClass
     30    public static void setUpClass() {
     31        JOSMFixture.createUnitTestFixture().init();
     32    }
     33
     34    /**
     35     * Test {@link Predicates#alwaysTrue()}
     36     */
     37    @Test
     38    public void testAlwaysTrue() {
     39        Predicate<Object> alwaysTrue = Predicates.alwaysTrue();
     40        assertTrue(alwaysTrue.evaluate(new Object()));
     41        assertTrue(alwaysTrue.evaluate(Boolean.TRUE));
     42    }
     43
     44    /**
     45     * Test {@link Predicates#alwaysFalse()}
     46     */
     47    @Test
     48    public void testAlwaysFalse() {
     49        Predicate<Object> alwaysFalse = Predicates.alwaysFalse();
     50        assertFalse(alwaysFalse.evaluate(new Object()));
     51        assertFalse(alwaysFalse.evaluate(Boolean.TRUE));
     52    }
     53
     54    /**
     55     * Test {@link Predicates#not(Predicate)}
     56     */
     57    @Test
     58    public void testNot() {
     59        Predicate<Boolean> not = Predicates.not(new Predicate<Boolean>() {
     60            @Override
     61            public boolean evaluate(Boolean object) {
     62                return object;
     63            }
     64        });
     65        assertFalse(not.evaluate(Boolean.TRUE));
     66        assertTrue(not.evaluate(Boolean.FALSE));
     67    }
     68
     69    /**
     70     * Test {@link Predicates#equalTo(Object)}
     71     */
     72    @Test
     73    public void testEqualTo() {
     74        Integer testObject = new Integer(1);
     75        Predicate<Integer> equalTo = Predicates.equalTo(testObject);
     76        assertTrue(equalTo.evaluate(testObject));
     77        assertTrue(equalTo.evaluate(new Integer(1)));
     78
     79        assertFalse(equalTo.evaluate(new Integer(2)));
     80        assertFalse(equalTo.evaluate(null));
     81    }
     82
     83    /**
     84     * Test {@link Predicates#isOfClass(Class)}
     85     */
     86    @Test
     87    public void testIsOfClass() {
     88        Predicate<Object> isOfClass = Predicates.<Object>isOfClass(Hashtable.class);
     89        assertFalse(isOfClass.evaluate(null));
     90        assertFalse(isOfClass.evaluate(new Object()));
     91        assertFalse(isOfClass.evaluate(new Properties()));
     92        assertTrue(isOfClass.evaluate(new Hashtable<>()));
     93    }
     94
     95    /**
     96     * Test {@link Predicates#isOfClass(Class)}
     97     */
     98    @Test
     99    public void testIsInstanceOf() {
     100        Predicate<Object> isInstanceOf = Predicates.<Object>isInstanceOf(Hashtable.class);
     101        assertFalse(isInstanceOf.evaluate(null));
     102        assertFalse(isInstanceOf.evaluate(new Object()));
     103        assertTrue(isInstanceOf.evaluate(new Properties()));
     104        assertTrue(isInstanceOf.evaluate(new Hashtable<>()));
     105    }
     106
     107    /**
     108     * Test {@link Predicates#stringMatchesPattern(java.util.regex.Pattern)}
     109     */
     110    @Test
     111    public void testStringMatchesPattern() {
     112        Pattern p = Pattern.compile("ab?c");
     113        Predicate<String> stringMatchesPattern = Predicates.stringMatchesPattern(p);
     114        assertFalse(stringMatchesPattern.evaluate(""));
     115        assertFalse(stringMatchesPattern.evaluate("a"));
     116        assertFalse(stringMatchesPattern.evaluate("xabcx"));
     117        assertTrue(stringMatchesPattern.evaluate("ac"));
     118        assertTrue(stringMatchesPattern.evaluate("abc"));
     119    }
     120
     121    /**
     122     * Test {@link Predicates#stringContainsPattern(java.util.regex.Pattern)}
     123     */
     124    @Test
     125    public void testStringContainsPattern() {
     126        Pattern p = Pattern.compile("ab?c");
     127        Predicate<String> stringContainsPattern = Predicates.stringContainsPattern(p);
     128        assertFalse(stringContainsPattern.evaluate(""));
     129        assertFalse(stringContainsPattern.evaluate("a"));
     130        assertTrue(stringContainsPattern.evaluate("xabcx"));
     131        assertTrue(stringContainsPattern.evaluate("ac"));
     132        assertTrue(stringContainsPattern.evaluate("abc"));
     133        assertTrue(stringContainsPattern.evaluate("xx\nabc\nx"));
     134    }
     135
     136    /**
     137     * Test {@link Predicates#stringContains(String)}
     138     */
     139    @Test
     140    public void testStringContains() {
     141        Predicate<String> stringContains = Predicates.stringContains("abc");
     142        assertFalse(stringContains.evaluate(""));
     143        assertFalse(stringContains.evaluate("a"));
     144        assertTrue(stringContains.evaluate("xabcx"));
     145        assertFalse(stringContains.evaluate("ac"));
     146        assertTrue(stringContains.evaluate("abc"));
     147    }
     148
     149    /**
     150     * Test {@link Predicates#hasTag(String, String...)}
     151     */
     152    @Test
     153    public void testHasTag() {
     154        Predicate<OsmPrimitive> hasTag = Predicates.hasTag("key", "value");
     155        Node n1 = new Node();
     156        assertFalse(hasTag.evaluate(n1));
     157        n1.put("Key", "x");
     158        assertFalse(hasTag.evaluate(n1));
     159        n1.put("key", "x");
     160        assertFalse(hasTag.evaluate(n1));
     161        n1.put("key", "value");
     162        assertTrue(hasTag.evaluate(n1));
     163    }
     164
     165    /**
     166     * Test {@link Predicates#hasKey(String)}
     167     */
     168    @Test
     169    public void testHasKey() {
     170        Predicate<OsmPrimitive> hasKey = Predicates.hasKey("key");
     171        Node n1 = new Node();
     172        assertFalse(hasKey.evaluate(n1));
     173        n1.put("Key", "x");
     174        assertFalse(hasKey.evaluate(n1));
     175        n1.put("key", "x");
     176        assertTrue(hasKey.evaluate(n1));
     177    }
     178
     179    /**
     180     * Test {@link Predicates#inCollection(java.util.Collection)}
     181     */
     182    @Test
     183    public void testInCollection() {
     184        List<String> list = Arrays.asList("a", "b", "c");
     185        Predicate<String> inCollection = Predicates.inCollection(list);
     186        assertTrue(inCollection.evaluate("a"));
     187        assertTrue(inCollection.evaluate("c"));
     188        assertFalse(inCollection.evaluate("d"));
     189        assertFalse(inCollection.evaluate(null));
     190
     191        List<String> list2 = Arrays.asList("a", "b", "c", null);
     192        Predicate<String> inCollection2 = Predicates.inCollection(list2);
     193        assertTrue(inCollection2.evaluate("a"));
     194        assertTrue(inCollection2.evaluate("c"));
     195        assertFalse(inCollection2.evaluate("d"));
     196        assertTrue(inCollection2.evaluate(null));
     197    }
     198
     199    /**
     200     * Test {@link Predicates#isNull()}
     201     */
     202    @Test
     203    public void testIsNull() {
     204        Predicate<Object> isNull = Predicates.isNull();
     205        assertTrue(isNull.evaluate(null));
     206        assertFalse(isNull.evaluate(new Integer(2)));
     207    }
     208}