Ignore:
Timestamp:
2010-09-15T18:53:09+02:00 (14 years ago)
Author:
stoecker
Message:

remove tabs

Location:
applications/editors/josm/plugins/graphview/test/org/openstreetmap/josm/plugins/graphview/core
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/graphview/test/org/openstreetmap/josm/plugins/graphview/core/FullGraphCreationTest.java

    r19216 r23189  
    3232public class FullGraphCreationTest {
    3333
    34         private static final AccessParameters ACCESS_PARAMS;
    35         static {
    36                 Map<VehiclePropertyType<?>, String> vehiclePropertyValues =
    37                         new HashMap<VehiclePropertyType<?>, String>();
    38                 vehiclePropertyValues.put(VehiclePropertyTypes.WIDTH, "3.0");
     34    private static final AccessParameters ACCESS_PARAMS;
     35    static {
     36        Map<VehiclePropertyType<?>, String> vehiclePropertyValues =
     37            new HashMap<VehiclePropertyType<?>, String>();
     38        vehiclePropertyValues.put(VehiclePropertyTypes.WIDTH, "3.0");
    3939
    40                 try {
    41                         ACCESS_PARAMS = new PreferenceAccessParameters(
    42                                         "test_vehicle",
    43                                         Arrays.asList(AccessType.UNDEFINED),
    44                                         vehiclePropertyValues);
    45                 } catch (PropertyValueSyntaxException e) {
    46                         throw new Error(e);
    47                 }
    48         }
     40        try {
     41            ACCESS_PARAMS = new PreferenceAccessParameters(
     42                    "test_vehicle",
     43                    Arrays.asList(AccessType.UNDEFINED),
     44                    vehiclePropertyValues);
     45        } catch (PropertyValueSyntaxException e) {
     46            throw new Error(e);
     47        }
     48    }
    4949
    50         private static final AccessRuleset TEST_RULESET = new AccessRuleset() {
    51                 public java.util.List<String> getAccessHierarchyAncestors(String transportMode) {
    52                         return Arrays.asList(transportMode);
    53                 }
    54                 public java.util.Collection<Tag> getBaseTags() {
    55                         return Arrays.asList(new Tag("highway", "test"));
    56                 }
    57                 public java.util.List<Implication> getImplications() {
    58                         return new LinkedList<Implication>();
    59                 }
    60         };
     50    private static final AccessRuleset TEST_RULESET = new AccessRuleset() {
     51        public java.util.List<String> getAccessHierarchyAncestors(String transportMode) {
     52            return Arrays.asList(transportMode);
     53        }
     54        public java.util.Collection<Tag> getBaseTags() {
     55            return Arrays.asList(new Tag("highway", "test"));
     56        }
     57        public java.util.List<Implication> getImplications() {
     58            return new LinkedList<Implication>();
     59        }
     60    };
    6161
    62         @Test
    63         public void testTJunction() {
     62    @Test
     63    public void testTJunction() {
    6464
    65                 TestDataSource ds = new TestDataSource();
     65        TestDataSource ds = new TestDataSource();
    6666
    67                 TestNode nodeN = new TestNode(2, 1);
    68                 TestNode nodeW = new TestNode(1, 0);
    69                 TestNode nodeS = new TestNode(0, 1);
    70                 TestNode nodeC = new TestNode(1, 1);
     67        TestNode nodeN = new TestNode(2, 1);
     68        TestNode nodeW = new TestNode(1, 0);
     69        TestNode nodeS = new TestNode(0, 1);
     70        TestNode nodeC = new TestNode(1, 1);
    7171
    72                 ds.nodes.addAll(Arrays.asList(nodeN, nodeW, nodeS, nodeC));
     72        ds.nodes.addAll(Arrays.asList(nodeN, nodeW, nodeS, nodeC));
    7373
    74                 TestWay wayNC = new TestWay();
    75                 wayNC.tags.put("highway", "test");
    76                 wayNC.nodes.addAll(Arrays.asList(nodeN, nodeC));
    77                 TestWay wayCS = new TestWay();
    78                 wayCS.tags.put("highway", "test");
    79                 wayCS.nodes.addAll(Arrays.asList(nodeC, nodeS));
    80                 TestWay wayCW = new TestWay();
    81                 wayCW.tags.put("highway", "test");
    82                 wayCW.nodes.addAll(Arrays.asList(nodeC, nodeW));
     74        TestWay wayNC = new TestWay();
     75        wayNC.tags.put("highway", "test");
     76        wayNC.nodes.addAll(Arrays.asList(nodeN, nodeC));
     77        TestWay wayCS = new TestWay();
     78        wayCS.tags.put("highway", "test");
     79        wayCS.nodes.addAll(Arrays.asList(nodeC, nodeS));
     80        TestWay wayCW = new TestWay();
     81        wayCW.tags.put("highway", "test");
     82        wayCW.nodes.addAll(Arrays.asList(nodeC, nodeW));
    8383
    84                 ds.ways.add(wayNC);
    85                 ds.ways.add(wayCS);
    86                 ds.ways.add(wayCW);
     84        ds.ways.add(wayNC);
     85        ds.ways.add(wayCS);
     86        ds.ways.add(wayCW);
    8787
    88                 /* variant 1: no restrictions */
    89                 {
    90                         TransitionStructure ts1 = createTestTransitionStructure(ds);
     88        /* variant 1: no restrictions */
     89        {
     90            TransitionStructure ts1 = createTestTransitionStructure(ds);
    9191
    92                         assertSame(4, size(ts1.getNodes()));
    93                         assertSame(6, size(ts1.getSegments()));
    94                         assertSame(0, size(ts1.getRestrictions()));
     92            assertSame(4, size(ts1.getNodes()));
     93            assertSame(6, size(ts1.getSegments()));
     94            assertSame(0, size(ts1.getRestrictions()));
    9595
    96                         WayGraph graph1 = new TSBasedWayGraph(ts1);
     96            WayGraph graph1 = new TSBasedWayGraph(ts1);
    9797
    98                         assertSame(12, graph1.getNodes().size());
    99                         assertSame(24, graph1.getEdges().size());
    100                 }
    101                 /* variant 2: no left turn from S to W */
    102                 {
    103                         ds.relations.add(createTurnRestrictionRelation(wayCS, nodeC, wayCW, "no_left_turn"));
    104                         TransitionStructure ts2 = createTestTransitionStructure(ds);
     98            assertSame(12, graph1.getNodes().size());
     99            assertSame(24, graph1.getEdges().size());
     100        }
     101        /* variant 2: no left turn from S to W */
     102        {
     103            ds.relations.add(createTurnRestrictionRelation(wayCS, nodeC, wayCW, "no_left_turn"));
     104            TransitionStructure ts2 = createTestTransitionStructure(ds);
    105105
    106                         assertSame(4, size(ts2.getNodes()));
    107                         assertSame(6, size(ts2.getSegments()));
    108                         assertSame(1, size(ts2.getRestrictions()));
     106            assertSame(4, size(ts2.getNodes()));
     107            assertSame(6, size(ts2.getSegments()));
     108            assertSame(1, size(ts2.getRestrictions()));
    109109
    110                         WayGraph graph2 = new TSBasedWayGraph(ts2);
     110            WayGraph graph2 = new TSBasedWayGraph(ts2);
    111111
    112                         assertSame(12, graph2.getNodes().size());
    113                         assertSame(23, graph2.getEdges().size());
    114                 }
     112            assertSame(12, graph2.getNodes().size());
     113            assertSame(23, graph2.getEdges().size());
     114        }
    115115
    116         }
     116    }
    117117
    118         @Test
    119         public void testBarrier() {
     118    @Test
     119    public void testBarrier() {
    120120
    121                 TestDataSource ds = new TestDataSource();
     121        TestDataSource ds = new TestDataSource();
    122122
    123                 TestNode node1 = new TestNode(0, 1);
    124                 TestNode nodeB = new TestNode(0, 2);
    125                 nodeB.tags.put("width", "1");
    126                 TestNode node2 = new TestNode(0, 3);
     123        TestNode node1 = new TestNode(0, 1);
     124        TestNode nodeB = new TestNode(0, 2);
     125        nodeB.tags.put("width", "1");
     126        TestNode node2 = new TestNode(0, 3);
    127127
    128                 ds.nodes.addAll(Arrays.asList(node1, nodeB, node2));
     128        ds.nodes.addAll(Arrays.asList(node1, nodeB, node2));
    129129
    130                 TestWay way = new TestWay();
    131                 way.tags.put("highway", "test");
    132                 way.tags.put("oneway", "yes");
    133                 way.nodes.addAll(Arrays.asList(node1, nodeB, node2));
    134                 ds.ways.add(way);
     130        TestWay way = new TestWay();
     131        way.tags.put("highway", "test");
     132        way.tags.put("oneway", "yes");
     133        way.nodes.addAll(Arrays.asList(node1, nodeB, node2));
     134        ds.ways.add(way);
    135135
    136                 /* variant 1: no restrictions */
     136        /* variant 1: no restrictions */
    137137
    138                 TransitionStructure ts = createTestTransitionStructure(ds);
     138        TransitionStructure ts = createTestTransitionStructure(ds);
    139139
    140                 assertSame(3, size(ts.getNodes()));
    141                 assertSame(2, size(ts.getSegments()));
    142                 assertSame(1, size(ts.getRestrictions()));
     140        assertSame(3, size(ts.getNodes()));
     141        assertSame(2, size(ts.getSegments()));
     142        assertSame(1, size(ts.getRestrictions()));
    143143
    144                 WayGraph graph = new TSBasedWayGraph(ts);
     144        WayGraph graph = new TSBasedWayGraph(ts);
    145145
    146                 assertSame(4, graph.getNodes().size());
    147                 assertSame(2, graph.getEdges().size());
     146        assertSame(4, graph.getNodes().size());
     147        assertSame(2, graph.getEdges().size());
    148148
    149         }
     149    }
    150150
    151         private TestRelation createTurnRestrictionRelation(
    152                         TestWay from, TestNode via, TestWay to, String restriction) {
    153                 TestRelation resultRelation = new TestRelation();
    154                 resultRelation.tags.put("type", "restriction");
    155                 resultRelation.tags.put("restriction", restriction);
    156                 resultRelation.members.add(new TestRelationMember("from", from));
    157                 resultRelation.members.add(new TestRelationMember("via", via));
    158                 resultRelation.members.add(new TestRelationMember("to", to));
    159                 return resultRelation;
    160         }
     151    private TestRelation createTurnRestrictionRelation(
     152            TestWay from, TestNode via, TestWay to, String restriction) {
     153        TestRelation resultRelation = new TestRelation();
     154        resultRelation.tags.put("type", "restriction");
     155        resultRelation.tags.put("restriction", restriction);
     156        resultRelation.members.add(new TestRelationMember("from", from));
     157        resultRelation.members.add(new TestRelationMember("via", via));
     158        resultRelation.members.add(new TestRelationMember("to", to));
     159        return resultRelation;
     160    }
    161161
    162         private TransitionStructure createTestTransitionStructure(TestDataSource dataSource) {
     162    private TransitionStructure createTestTransitionStructure(TestDataSource dataSource) {
    163163
    164                 LinkedList<RoadPropertyType<?>> properties = new LinkedList<RoadPropertyType<?>>();
    165                 properties.add(new RoadWidth());
     164        LinkedList<RoadPropertyType<?>> properties = new LinkedList<RoadPropertyType<?>>();
     165        properties.add(new RoadWidth());
    166166
    167                 return new GenericTransitionStructure<TestNode, TestWay, TestRelation, TestRelationMember>(
    168                                 ACCESS_PARAMS, TEST_RULESET, dataSource, properties);
    169         }
     167        return new GenericTransitionStructure<TestNode, TestWay, TestRelation, TestRelationMember>(
     168                ACCESS_PARAMS, TEST_RULESET, dataSource, properties);
     169    }
    170170
    171         private static int size(Iterable<?> iterable) {
    172                 Iterator<?> iterator = iterable.iterator();
    173                 int size = 0;
    174                 while (iterator.hasNext()) {
    175                         iterator.next();
    176                         size ++;
    177                 }
    178                 return size;
    179         }
     171    private static int size(Iterable<?> iterable) {
     172        Iterator<?> iterator = iterable.iterator();
     173        int size = 0;
     174        while (iterator.hasNext()) {
     175            iterator.next();
     176            size ++;
     177        }
     178        return size;
     179    }
    180180
    181181}

  • applications/editors/josm/plugins/graphview/test/org/openstreetmap/josm/plugins/graphview/core/TestDataSource.java

    r19216 r23189  
    1414public class TestDataSource implements DataSource<TestDataSource.TestNode, TestDataSource.TestWay, TestDataSource.TestRelation, TestDataSource.TestRelationMember> {
    1515
    16         public static class TestPrimitive {
    17                 public final Map<String, String> tags = new HashMap<String, String>();
    18         };
     16    public static class TestPrimitive {
     17        public final Map<String, String> tags = new HashMap<String, String>();
     18    };
    1919
    20         public static class TestNode extends TestPrimitive {
    21                 public final double lat;
    22                 public final double lon;
    23                 public TestNode() {
    24                         this(0, 0);
    25                 }
    26                 public TestNode(double lat, double lon) {
    27                         this.lat = lat;
    28                         this.lon = lon;
    29                 }
    30                 @Override
    31                 public String toString() {
    32                         return "(" + lat + ", " + lon + "); " + tags;
    33                 }
    34         }
     20    public static class TestNode extends TestPrimitive {
     21        public final double lat;
     22        public final double lon;
     23        public TestNode() {
     24            this(0, 0);
     25        }
     26        public TestNode(double lat, double lon) {
     27            this.lat = lat;
     28            this.lon = lon;
     29        }
     30        @Override
     31        public String toString() {
     32            return "(" + lat + ", " + lon + "); " + tags;
     33        }
     34    }
    3535
    36         public static class TestWay extends TestPrimitive {
    37                 public final List<TestNode> nodes = new LinkedList<TestNode>();
    38                 @Override
    39                 public String toString() {
    40                         return nodes + "; " + tags;
    41                 }
    42         }
     36    public static class TestWay extends TestPrimitive {
     37        public final List<TestNode> nodes = new LinkedList<TestNode>();
     38        @Override
     39        public String toString() {
     40            return nodes + "; " + tags;
     41        }
     42    }
    4343
    44         public static class TestRelation extends TestPrimitive {
    45                 public final Collection<TestRelationMember> members = new LinkedList<TestRelationMember>();
    46                 @Override
    47                 public String toString() {
    48                         return members + "; " + tags;
    49                 }
    50         }
     44    public static class TestRelation extends TestPrimitive {
     45        public final Collection<TestRelationMember> members = new LinkedList<TestRelationMember>();
     46        @Override
     47        public String toString() {
     48            return members + "; " + tags;
     49        }
     50    }
    5151
    52         public static class TestRelationMember {
    53                 public final String role;
    54                 public final TestPrimitive member;
    55                 public TestRelationMember(String role, TestPrimitive member) {
    56                         this.role = role;
    57                         this.member = member;
    58                 }
    59                 public TestPrimitive getMember() {
    60                         return member;
    61                 }
    62                 public String getRole() {
    63                         return role;
    64                 }
    65                 @Override
    66                 public String toString() {
    67                         return role + "=" + member;
    68                 }
    69         }
     52    public static class TestRelationMember {
     53        public final String role;
     54        public final TestPrimitive member;
     55        public TestRelationMember(String role, TestPrimitive member) {
     56            this.role = role;
     57            this.member = member;
     58        }
     59        public TestPrimitive getMember() {
     60            return member;
     61        }
     62        public String getRole() {
     63            return role;
     64        }
     65        @Override
     66        public String toString() {
     67            return role + "=" + member;
     68        }
     69    }
    7070
    7171
    72         public final Collection<TestNode> nodes = new LinkedList<TestNode>();
    73         public final Collection<TestWay> ways = new LinkedList<TestWay>();
    74         public final Collection<TestRelation> relations = new LinkedList<TestRelation>();
     72    public final Collection<TestNode> nodes = new LinkedList<TestNode>();
     73    public final Collection<TestWay> ways = new LinkedList<TestWay>();
     74    public final Collection<TestRelation> relations = new LinkedList<TestRelation>();
    7575
    7676
    77         public double getLat(TestNode node) {
    78                 return node.lat;
    79         }
    80         public double getLon(TestNode node) {
    81                 return node.lon;
    82         }
     77    public double getLat(TestNode node) {
     78        return node.lat;
     79    }
     80    public double getLon(TestNode node) {
     81        return node.lon;
     82    }
    8383
    84         public Iterable<TestRelationMember> getMembers(TestRelation relation) {
    85                 return relation.members;
    86         }
     84    public Iterable<TestRelationMember> getMembers(TestRelation relation) {
     85        return relation.members;
     86    }
    8787
    88         public Iterable<TestNode> getNodes() {
    89                 return nodes;
    90         }
     88    public Iterable<TestNode> getNodes() {
     89        return nodes;
     90    }
    9191
    92         public Iterable<TestNode> getNodes(TestWay way) {
    93                 return way.nodes;
    94         }
     92    public Iterable<TestNode> getNodes(TestWay way) {
     93        return way.nodes;
     94    }
    9595
    96         public Iterable<TestWay> getWays() {
    97                 return ways;
    98         }
     96    public Iterable<TestWay> getWays() {
     97        return ways;
     98    }
    9999
    100         public Iterable<TestRelation> getRelations() {
    101                 return relations;
    102         }
     100    public Iterable<TestRelation> getRelations() {
     101        return relations;
     102    }
    103103
    104         public TagGroup getTagsN(TestNode node) {
    105                 return new MapBasedTagGroup(node.tags);
    106         }
     104    public TagGroup getTagsN(TestNode node) {
     105        return new MapBasedTagGroup(node.tags);
     106    }
    107107
    108         public TagGroup getTagsW(TestWay way) {
    109                 return new MapBasedTagGroup(way.tags);
    110         }
     108    public TagGroup getTagsW(TestWay way) {
     109        return new MapBasedTagGroup(way.tags);
     110    }
    111111
    112         public TagGroup getTagsR(TestRelation relation) {
    113                 return new MapBasedTagGroup(relation.tags);
    114         }
    115        
    116         public Object getMember(TestRelationMember member) {
    117                 return member.getMember();
    118         }
    119        
    120         public String getRole(TestRelationMember member) {
    121                 return member.getRole();
    122         }
    123        
    124         public boolean isNMember(TestRelationMember member) {
    125                 return member.getMember() instanceof TestNode;
    126         }
    127        
    128         public boolean isWMember(TestRelationMember member) {
    129                 return member.getMember() instanceof TestWay;
    130         }
    131        
    132         public boolean isRMember(TestRelationMember member) {
    133                 return member.getMember() instanceof TestRelation;
    134         }
     112    public TagGroup getTagsR(TestRelation relation) {
     113        return new MapBasedTagGroup(relation.tags);
     114    }
    135115
    136         public void addObserver(DataSourceObserver observer) {
    137                 // not needed for test
    138         }
     116    public Object getMember(TestRelationMember member) {
     117        return member.getMember();
     118    }
    139119
    140         public void deleteObserver(DataSourceObserver observer) {
    141                 // not needed for test
    142         }
     120    public String getRole(TestRelationMember member) {
     121        return member.getRole();
     122    }
     123
     124    public boolean isNMember(TestRelationMember member) {
     125        return member.getMember() instanceof TestNode;
     126    }
     127
     128    public boolean isWMember(TestRelationMember member) {
     129        return member.getMember() instanceof TestWay;
     130    }
     131
     132    public boolean isRMember(TestRelationMember member) {
     133        return member.getMember() instanceof TestRelation;
     134    }
     135
     136    public void addObserver(DataSourceObserver observer) {
     137        // not needed for test
     138    }
     139
     140    public void deleteObserver(DataSourceObserver observer) {
     141        // not needed for test
     142    }
    143143
    144144}

  • applications/editors/josm/plugins/graphview/test/org/openstreetmap/josm/plugins/graphview/core/access/AccessRulesetReaderTest.java

    r16520 r23189  
    2222public class AccessRulesetReaderTest {
    2323
    24         @Test
    25         public void testReadAccessRuleset_valid_classes() throws IOException {
     24    @Test
     25    public void testReadAccessRuleset_valid_classes() throws IOException {
    2626
    27                 InputStream is = new FileInputStream("plugins/graphview/test/files/accessRuleset_valid.xml");
    28                 AccessRuleset ruleset = AccessRulesetReader.readAccessRuleset(is);
    29                 assertNotNull(ruleset);
     27        InputStream is = new FileInputStream("plugins/graphview/test/files/accessRuleset_valid.xml");
     28        AccessRuleset ruleset = AccessRulesetReader.readAccessRuleset(is);
     29        assertNotNull(ruleset);
    3030
    3131
    32                 assertEquals("vehicle", ruleset.getAccessHierarchyAncestors("vehicle").get(0));
     32        assertEquals("vehicle", ruleset.getAccessHierarchyAncestors("vehicle").get(0));
    3333
    34                 assertEquals("motor_vehicle", ruleset.getAccessHierarchyAncestors("motor_vehicle").get(0));
    35                 assertEquals("vehicle", ruleset.getAccessHierarchyAncestors("motor_vehicle").get(1));
     34        assertEquals("motor_vehicle", ruleset.getAccessHierarchyAncestors("motor_vehicle").get(0));
     35        assertEquals("vehicle", ruleset.getAccessHierarchyAncestors("motor_vehicle").get(1));
    3636
    37                 assertEquals("bus", ruleset.getAccessHierarchyAncestors("bus").get(0));
    38                 assertEquals("motor_vehicle", ruleset.getAccessHierarchyAncestors("bus").get(1));
    39                 assertEquals("vehicle", ruleset.getAccessHierarchyAncestors("bus").get(2));
     37        assertEquals("bus", ruleset.getAccessHierarchyAncestors("bus").get(0));
     38        assertEquals("motor_vehicle", ruleset.getAccessHierarchyAncestors("bus").get(1));
     39        assertEquals("vehicle", ruleset.getAccessHierarchyAncestors("bus").get(2));
    4040
    41                 assertEquals("bicycle", ruleset.getAccessHierarchyAncestors("bicycle").get(0));
    42                 assertEquals("vehicle", ruleset.getAccessHierarchyAncestors("bicycle").get(1));
     41        assertEquals("bicycle", ruleset.getAccessHierarchyAncestors("bicycle").get(0));
     42        assertEquals("vehicle", ruleset.getAccessHierarchyAncestors("bicycle").get(1));
    4343
    44                 assertFalse(ruleset.getAccessHierarchyAncestors("bus").contains("bicycle"));
     44        assertFalse(ruleset.getAccessHierarchyAncestors("bus").contains("bicycle"));
    4545
    46                 assertSame(ruleset.getAccessHierarchyAncestors("boat").size(), 0);
     46        assertSame(ruleset.getAccessHierarchyAncestors("boat").size(), 0);
    4747
    48         }
     48    }
    4949
    50         @Test
    51         public void testReadAccessRuleset_valid_basetags() throws IOException {
     50    @Test
     51    public void testReadAccessRuleset_valid_basetags() throws IOException {
    5252
    53                 InputStream is = new FileInputStream("plugins/graphview/test/files/accessRuleset_valid.xml");
    54                 AccessRuleset ruleset = AccessRulesetReader.readAccessRuleset(is);
    55                 assertNotNull(ruleset);
     53        InputStream is = new FileInputStream("plugins/graphview/test/files/accessRuleset_valid.xml");
     54        AccessRuleset ruleset = AccessRulesetReader.readAccessRuleset(is);
     55        assertNotNull(ruleset);
    5656
    57                 assertSame(2, ruleset.getBaseTags().size());
     57        assertSame(2, ruleset.getBaseTags().size());
    5858
    59                 assertTrue(ruleset.getBaseTags().contains(new Tag("highway", "residential")));
    60                 assertTrue(ruleset.getBaseTags().contains(new Tag("highway", "cycleway")));
    61                 assertFalse(ruleset.getBaseTags().contains(new Tag("building", "residential")));
    62                 assertFalse(ruleset.getBaseTags().contains(new Tag("highway", "stop")));
     59        assertTrue(ruleset.getBaseTags().contains(new Tag("highway", "residential")));
     60        assertTrue(ruleset.getBaseTags().contains(new Tag("highway", "cycleway")));
     61        assertFalse(ruleset.getBaseTags().contains(new Tag("building", "residential")));
     62        assertFalse(ruleset.getBaseTags().contains(new Tag("highway", "stop")));
    6363
    64         }
     64    }
    6565
    66         @Test
    67         public void testReadAccessRuleset_valid_implications() throws IOException {
     66    @Test
     67    public void testReadAccessRuleset_valid_implications() throws IOException {
    6868
    69                 InputStream is = new FileInputStream("plugins/graphview/test/files/accessRuleset_valid.xml");
    70                 AccessRuleset ruleset = AccessRulesetReader.readAccessRuleset(is);
    71                 assertNotNull(ruleset);
     69        InputStream is = new FileInputStream("plugins/graphview/test/files/accessRuleset_valid.xml");
     70        AccessRuleset ruleset = AccessRulesetReader.readAccessRuleset(is);
     71        assertNotNull(ruleset);
    7272
    73                 List<Implication> implications = ruleset.getImplications();
     73        List<Implication> implications = ruleset.getImplications();
    7474
    75                 assertSame(3, implications.size());
     75        assertSame(3, implications.size());
    7676
    77                 TagGroup[] tagGroups = new TagGroup[4];
    78                 tagGroups[0] = createTagGroup(new Tag("highway", "cycleway"));
    79                 tagGroups[1] = createTagGroup(new Tag("highway", "steps"));
    80                 tagGroups[2] = createTagGroup(new Tag("highway", "steps"), new Tag("escalator", "yes"));
    81                 tagGroups[3] = createTagGroup(new Tag("disused", "yes"), new Tag("construction", "no"));
     77        TagGroup[] tagGroups = new TagGroup[4];
     78        tagGroups[0] = createTagGroup(new Tag("highway", "cycleway"));
     79        tagGroups[1] = createTagGroup(new Tag("highway", "steps"));
     80        tagGroups[2] = createTagGroup(new Tag("highway", "steps"), new Tag("escalator", "yes"));
     81        tagGroups[3] = createTagGroup(new Tag("disused", "yes"), new Tag("construction", "no"));
    8282
    83                 for (Implication implication : implications) {
    84                         for (int i = 0; i < tagGroups.length; i++) {
    85                                 tagGroups[i] = implication.apply(tagGroups[i]);
    86                         }
    87                 }
     83        for (Implication implication : implications) {
     84            for (int i = 0; i < tagGroups.length; i++) {
     85                tagGroups[i] = implication.apply(tagGroups[i]);
     86            }
     87        }
    8888
    89                 assertSame(2, tagGroups[0].size());
    90                 assertTrue(tagGroups[0].contains(new Tag("bicycle", "designated")));
     89        assertSame(2, tagGroups[0].size());
     90        assertTrue(tagGroups[0].contains(new Tag("bicycle", "designated")));
    9191
    92                 assertSame(2, tagGroups[1].size());
    93                 assertTrue(tagGroups[1].contains(new Tag("normal_steps", "yes")));
     92        assertSame(2, tagGroups[1].size());
     93        assertTrue(tagGroups[1].contains(new Tag("normal_steps", "yes")));
    9494
    95                 assertSame(2, tagGroups[2].size());
    96                 assertFalse(tagGroups[2].contains(new Tag("normal_steps", "yes")));
     95        assertSame(2, tagGroups[2].size());
     96        assertFalse(tagGroups[2].contains(new Tag("normal_steps", "yes")));
    9797
    98                 assertSame(3, tagGroups[3].size());
    99                 assertTrue(tagGroups[3].contains(new Tag("usable", "no")));
    100         }
     98        assertSame(3, tagGroups[3].size());
     99        assertTrue(tagGroups[3].contains(new Tag("usable", "no")));
     100    }
    101101
    102         private static TagGroup createTagGroup(Tag... tags) {
    103                 Map<String, String> tagMap = new HashMap<String, String>();
    104                 for (Tag tag : tags) {
    105                         tagMap.put(tag.key, tag.value);
    106                 }
    107                 return new MapBasedTagGroup(tagMap);
    108         }
     102    private static TagGroup createTagGroup(Tag... tags) {
     103        Map<String, String> tagMap = new HashMap<String, String>();
     104        for (Tag tag : tags) {
     105            tagMap.put(tag.key, tag.value);
     106        }
     107        return new MapBasedTagGroup(tagMap);
     108    }
    109109
    110110}

  • applications/editors/josm/plugins/graphview/test/org/openstreetmap/josm/plugins/graphview/core/property/RoadInclineTest.java

    r16520 r23189  
    66public class RoadInclineTest extends RoadPropertyTest {
    77
    8         private static void testIncline(Float expectedInclineForward, Float expectedInclineBackward,
    9                         String inclineString) {
     8    private static void testIncline(Float expectedInclineForward, Float expectedInclineBackward,
     9            String inclineString) {
    1010
    11                 testEvaluateW(new RoadIncline(),
    12                                 expectedInclineForward, expectedInclineBackward,
    13                                 new Tag("incline", inclineString));
    14         }
     11        testEvaluateW(new RoadIncline(),
     12                expectedInclineForward, expectedInclineBackward,
     13                new Tag("incline", inclineString));
     14    }
    1515
    16         @Test
    17         public void testEvaluate() {
    18                 testIncline(5f, -5f, "5 %");
    19                 testIncline(9.5f, -9.5f, "9.5 %");
    20                 testIncline(-2.5f, 2.5f, "-2.5%");
    21                 testIncline(null, null, "steep");
    22         }
     16    @Test
     17    public void testEvaluate() {
     18        testIncline(5f, -5f, "5 %");
     19        testIncline(9.5f, -9.5f, "9.5 %");
     20        testIncline(-2.5f, 2.5f, "-2.5%");
     21        testIncline(null, null, "steep");
     22    }
    2323
    2424}

  • applications/editors/josm/plugins/graphview/test/org/openstreetmap/josm/plugins/graphview/core/property/RoadMaxspeedTest.java

    r21609 r23189  
    66public class RoadMaxspeedTest extends RoadPropertyTest {
    77
    8         private static void testMaxspeed(float expectedMaxspeed, String maxspeedString) {
    9                 testEvaluateBoth(new RoadMaxspeed(),    expectedMaxspeed, new Tag("maxspeed", maxspeedString));
    10         }
     8    private static void testMaxspeed(float expectedMaxspeed, String maxspeedString) {
     9        testEvaluateBoth(new RoadMaxspeed(),    expectedMaxspeed, new Tag("maxspeed", maxspeedString));
     10    }
    1111
    12         @Test
    13         public void testEvaluate_numeric() {
    14                 testMaxspeed(30, "30");
    15                 testMaxspeed(48.3f, "48.3");
    16         }
     12    @Test
     13    public void testEvaluate_numeric() {
     14        testMaxspeed(30, "30");
     15        testMaxspeed(48.3f, "48.3");
     16    }
    1717
    18         @Test
    19         public void testEvaluate_kmh() {
    20                 testMaxspeed(50, "50 km/h");
    21                 testMaxspeed(120, "120km/h");
    22                 testMaxspeed(30, "30    km/h");
    23         }
     18    @Test
     19    public void testEvaluate_kmh() {
     20        testMaxspeed(50, "50 km/h");
     21        testMaxspeed(120, "120km/h");
     22        testMaxspeed(30, "30    km/h");
     23    }
    2424
    25         @Test
    26         public void testEvaluate_mph() {
    27                 testMaxspeed(72.42048f, "45 mph");
    28                 testMaxspeed(64.373764f, "40mph");
    29                 testMaxspeed(24.14016f, "15     mph");
    30         }
     25    @Test
     26    public void testEvaluate_mph() {
     27        testMaxspeed(72.42048f, "45 mph");
     28        testMaxspeed(64.373764f, "40mph");
     29        testMaxspeed(24.14016f, "15 mph");
     30    }
    3131
    3232}

  • applications/editors/josm/plugins/graphview/test/org/openstreetmap/josm/plugins/graphview/core/property/RoadPropertyTest.java

    r16520 r23189  
    88abstract public class RoadPropertyTest {
    99
    10         protected static <P> void testEvaluateW(RoadPropertyType<P> property, P expectedForward, P expectedBackward, Tag... wayTags) {
     10    protected static <P> void testEvaluateW(RoadPropertyType<P> property, P expectedForward, P expectedBackward, Tag... wayTags) {
    1111
    12                 TestDataSource ds = new TestDataSource();
    13                 TestDataSource.TestWay testWay = new TestDataSource.TestWay();
    14                 for (Tag tag : wayTags) {
    15                         testWay.tags.put(tag.key, tag.value);
    16                 }
    17                 ds.ways.add(testWay);
     12        TestDataSource ds = new TestDataSource();
     13        TestDataSource.TestWay testWay = new TestDataSource.TestWay();
     14        for (Tag tag : wayTags) {
     15            testWay.tags.put(tag.key, tag.value);
     16        }
     17        ds.ways.add(testWay);
    1818
    19                 assertEquals(expectedForward, property.evaluateW(testWay, true, null, ds));
    20                 assertEquals(expectedBackward, property.evaluateW(testWay, false, null, ds));
     19        assertEquals(expectedForward, property.evaluateW(testWay, true, null, ds));
     20        assertEquals(expectedBackward, property.evaluateW(testWay, false, null, ds));
    2121
    22         }
     22    }
    2323
    24         protected static <P> void testEvaluateN(RoadPropertyType<P> property, P expected, Tag... nodeTags) {
     24    protected static <P> void testEvaluateN(RoadPropertyType<P> property, P expected, Tag... nodeTags) {
    2525
    26                 TestDataSource ds = new TestDataSource();
    27                 TestDataSource.TestNode testNode = new TestDataSource.TestNode();
    28                 for (Tag tag : nodeTags) {
    29                         testNode.tags.put(tag.key, tag.value);
    30                 }
    31                 ds.nodes.add(testNode);
     26        TestDataSource ds = new TestDataSource();
     27        TestDataSource.TestNode testNode = new TestDataSource.TestNode();
     28        for (Tag tag : nodeTags) {
     29            testNode.tags.put(tag.key, tag.value);
     30        }
     31        ds.nodes.add(testNode);
    3232
    33                 RoadMaxspeed m = new RoadMaxspeed();
     33        RoadMaxspeed m = new RoadMaxspeed();
    3434
    35                 assertEquals(expected, m.evaluateN(testNode, null, ds));
     35        assertEquals(expected, m.evaluateN(testNode, null, ds));
    3636
    37         }
     37    }
    3838
    39         protected static <P> void testEvaluateBoth(RoadPropertyType<P> property, P expected, Tag... nodeTags) {
    40                 testEvaluateW(property, expected, expected, nodeTags);
    41                 testEvaluateN(property, expected, nodeTags);
    42         }
     39    protected static <P> void testEvaluateBoth(RoadPropertyType<P> property, P expected, Tag... nodeTags) {
     40        testEvaluateW(property, expected, expected, nodeTags);
     41        testEvaluateN(property, expected, nodeTags);
     42    }
    4343
    4444}

  • applications/editors/josm/plugins/graphview/test/org/openstreetmap/josm/plugins/graphview/core/util/TagConditionLogicTest.java

    r16520 r23189  
    1515public class TagConditionLogicTest {
    1616
    17         TagGroup groupA;
    18         TagGroup groupB;
     17    TagGroup groupA;
     18    TagGroup groupB;
    1919
    20         @Before
    21         public void setUp() {
    22                 Map<String, String> mapA = new HashMap<String, String>();
    23                 mapA.put("key1", "value1");
    24                 mapA.put("key2", "value2");
    25                 mapA.put("key3", "value1");
    26                 groupA = new MapBasedTagGroup(mapA);
     20    @Before
     21    public void setUp() {
     22        Map<String, String> mapA = new HashMap<String, String>();
     23        mapA.put("key1", "value1");
     24        mapA.put("key2", "value2");
     25        mapA.put("key3", "value1");
     26        groupA = new MapBasedTagGroup(mapA);
    2727
    28                 Map<String, String> mapB = new HashMap<String, String>();
    29                 mapB.put("key1", "value1");
    30                 mapB.put("key4", "value4");
    31                 groupB = new MapBasedTagGroup(mapB);
    32         }
     28        Map<String, String> mapB = new HashMap<String, String>();
     29        mapB.put("key1", "value1");
     30        mapB.put("key4", "value4");
     31        groupB = new MapBasedTagGroup(mapB);
     32    }
    3333
    34         @Test
    35         public void testTag() {
    36                 TagCondition condition = TagConditionLogic.tag(new Tag("key3", "value1"));
    37                 assertTrue(condition.matches(groupA));
    38                 assertFalse(condition.matches(groupB));
    39         }
     34    @Test
     35    public void testTag() {
     36        TagCondition condition = TagConditionLogic.tag(new Tag("key3", "value1"));
     37        assertTrue(condition.matches(groupA));
     38        assertFalse(condition.matches(groupB));
     39    }
    4040
    41         @Test
    42         public void testKey() {
    43                 TagCondition condition = TagConditionLogic.key("key3");
    44                 assertTrue(condition.matches(groupA));
    45                 assertFalse(condition.matches(groupB));
    46         }
     41    @Test
     42    public void testKey() {
     43        TagCondition condition = TagConditionLogic.key("key3");
     44        assertTrue(condition.matches(groupA));
     45        assertFalse(condition.matches(groupB));
     46    }
    4747
    48         @Test
    49         public void testAnd() {
    50                 TagCondition condition1 = TagConditionLogic.tag(new Tag("key2", "value2"));
    51                 TagCondition conditionAnd1a = TagConditionLogic.and(condition1);
    52                 TagCondition conditionAnd1b = TagConditionLogic.and(Arrays.asList(condition1));
     48    @Test
     49    public void testAnd() {
     50        TagCondition condition1 = TagConditionLogic.tag(new Tag("key2", "value2"));
     51        TagCondition conditionAnd1a = TagConditionLogic.and(condition1);
     52        TagCondition conditionAnd1b = TagConditionLogic.and(Arrays.asList(condition1));
    5353
    54                 assertTrue(conditionAnd1a.matches(groupA));
    55                 assertTrue(conditionAnd1b.matches(groupA));
    56                 assertFalse(conditionAnd1a.matches(groupB));
    57                 assertFalse(conditionAnd1b.matches(groupB));
     54        assertTrue(conditionAnd1a.matches(groupA));
     55        assertTrue(conditionAnd1b.matches(groupA));
     56        assertFalse(conditionAnd1a.matches(groupB));
     57        assertFalse(conditionAnd1b.matches(groupB));
    5858
    59                 TagCondition condition2 = TagConditionLogic.tag(new Tag("key1", "value1"));
    60                 TagCondition conditionAnd2a = TagConditionLogic.and(condition1, condition2);
    61                 TagCondition conditionAnd2b = TagConditionLogic.and(Arrays.asList(condition1, condition2));
     59        TagCondition condition2 = TagConditionLogic.tag(new Tag("key1", "value1"));
     60        TagCondition conditionAnd2a = TagConditionLogic.and(condition1, condition2);
     61        TagCondition conditionAnd2b = TagConditionLogic.and(Arrays.asList(condition1, condition2));
    6262
    63                 assertTrue(conditionAnd2a.matches(groupA));
    64                 assertTrue(conditionAnd2b.matches(groupA));
    65                 assertFalse(conditionAnd2a.matches(groupB));
    66                 assertFalse(conditionAnd2b.matches(groupB));
     63        assertTrue(conditionAnd2a.matches(groupA));
     64        assertTrue(conditionAnd2b.matches(groupA));
     65        assertFalse(conditionAnd2a.matches(groupB));
     66        assertFalse(conditionAnd2b.matches(groupB));
    6767
    68                 TagCondition condition3 = TagConditionLogic.tag(new Tag("key4", "value4"));
    69                 TagCondition conditionAnd3a = TagConditionLogic.and(condition1, condition2, condition3);
    70                 TagCondition conditionAnd3b = TagConditionLogic.and(Arrays.asList(condition1, condition2, condition3));
     68        TagCondition condition3 = TagConditionLogic.tag(new Tag("key4", "value4"));
     69        TagCondition conditionAnd3a = TagConditionLogic.and(condition1, condition2, condition3);
     70        TagCondition conditionAnd3b = TagConditionLogic.and(Arrays.asList(condition1, condition2, condition3));
    7171
    72                 assertFalse(conditionAnd3a.matches(groupA));
    73                 assertFalse(conditionAnd3b.matches(groupA));
    74                 assertFalse(conditionAnd3a.matches(groupB));
    75                 assertFalse(conditionAnd3b.matches(groupB));
    76         }
     72        assertFalse(conditionAnd3a.matches(groupA));
     73        assertFalse(conditionAnd3b.matches(groupA));
     74        assertFalse(conditionAnd3a.matches(groupB));
     75        assertFalse(conditionAnd3b.matches(groupB));
     76    }
    7777
    78         @Test
    79         public void testOr() {
    80                 TagCondition condition1 = TagConditionLogic.tag(new Tag("key42", "value42"));
    81                 TagCondition conditionOr1a = TagConditionLogic.or(condition1);
    82                 TagCondition conditionOr1b = TagConditionLogic.or(Arrays.asList(condition1));
     78    @Test
     79    public void testOr() {
     80        TagCondition condition1 = TagConditionLogic.tag(new Tag("key42", "value42"));
     81        TagCondition conditionOr1a = TagConditionLogic.or(condition1);
     82        TagCondition conditionOr1b = TagConditionLogic.or(Arrays.asList(condition1));
    8383
    84                 assertFalse(conditionOr1a.matches(groupA));
    85                 assertFalse(conditionOr1b.matches(groupA));
    86                 assertFalse(conditionOr1a.matches(groupB));
    87                 assertFalse(conditionOr1b.matches(groupB));
     84        assertFalse(conditionOr1a.matches(groupA));
     85        assertFalse(conditionOr1b.matches(groupA));
     86        assertFalse(conditionOr1a.matches(groupB));
     87        assertFalse(conditionOr1b.matches(groupB));
    8888
    89                 TagCondition condition2 = TagConditionLogic.tag(new Tag("key3", "value1"));
    90                 TagCondition conditionOr2a = TagConditionLogic.or(condition1, condition2);
    91                 TagCondition conditionOr2b = TagConditionLogic.or(Arrays.asList(condition1, condition2));
     89        TagCondition condition2 = TagConditionLogic.tag(new Tag("key3", "value1"));
     90        TagCondition conditionOr2a = TagConditionLogic.or(condition1, condition2);
     91        TagCondition conditionOr2b = TagConditionLogic.or(Arrays.asList(condition1, condition2));
    9292
    93                 assertTrue(conditionOr2a.matches(groupA));
    94                 assertTrue(conditionOr2b.matches(groupA));
    95                 assertFalse(conditionOr2a.matches(groupB));
    96                 assertFalse(conditionOr2b.matches(groupB));
     93        assertTrue(conditionOr2a.matches(groupA));
     94        assertTrue(conditionOr2b.matches(groupA));
     95        assertFalse(conditionOr2a.matches(groupB));
     96        assertFalse(conditionOr2b.matches(groupB));
    9797
    98                 TagCondition condition3 = TagConditionLogic.tag(new Tag("key1", "value1"));
    99                 TagCondition conditionOr3a = TagConditionLogic.or(condition1, condition2, condition3);
    100                 TagCondition conditionOr3b = TagConditionLogic.or(Arrays.asList(condition1, condition2, condition3));
     98        TagCondition condition3 = TagConditionLogic.tag(new Tag("key1", "value1"));
     99        TagCondition conditionOr3a = TagConditionLogic.or(condition1, condition2, condition3);
     100        TagCondition conditionOr3b = TagConditionLogic.or(Arrays.asList(condition1, condition2, condition3));
    101101
    102                 assertTrue(conditionOr3a.matches(groupA));
    103                 assertTrue(conditionOr3b.matches(groupA));
    104                 assertTrue(conditionOr3a.matches(groupB));
    105                 assertTrue(conditionOr3b.matches(groupB));
    106         }
     102        assertTrue(conditionOr3a.matches(groupA));
     103        assertTrue(conditionOr3b.matches(groupA));
     104        assertTrue(conditionOr3a.matches(groupB));
     105        assertTrue(conditionOr3b.matches(groupB));
     106    }
    107107
    108         @Test
    109         public void testNot() {
    110                 TagCondition condition = TagConditionLogic.not(TagConditionLogic.key("key3"));
    111                 assertFalse(condition.matches(groupA));
    112                 assertTrue(condition.matches(groupB));
    113         }
     108    @Test
     109    public void testNot() {
     110        TagCondition condition = TagConditionLogic.not(TagConditionLogic.key("key3"));
     111        assertFalse(condition.matches(groupA));
     112        assertTrue(condition.matches(groupB));
     113    }
    114114
    115115}

  • applications/editors/josm/plugins/graphview/test/org/openstreetmap/josm/plugins/graphview/core/util/ValueStringParserTest.java

    r20244 r23189  
    1010public class ValueStringParserTest {
    1111
    12         /* speed */
     12    /* speed */
    1313
    14         @Test
    15         public void testParseSpeedDefault() {
    16                 assertClose(50, parseSpeed("50"));
    17         }
     14    @Test
     15    public void testParseSpeedDefault() {
     16        assertClose(50, parseSpeed("50"));
     17    }
    1818
    19         @Test
    20         public void testParseSpeedKmh() {
    21                 assertClose(30, parseSpeed("30 km/h"));
    22                 assertClose(100, parseSpeed("100km/h"));
    23         }
     19    @Test
     20    public void testParseSpeedKmh() {
     21        assertClose(30, parseSpeed("30 km/h"));
     22        assertClose(100, parseSpeed("100km/h"));
     23    }
    2424
    25         @Test
    26         public void testParseSpeedMph() {
    27                 assertClose(40.234f, parseSpeed("25mph"));
    28                 assertClose(40.234f, parseSpeed("25 mph"));
    29         }
     25    @Test
     26    public void testParseSpeedMph() {
     27        assertClose(40.234f, parseSpeed("25mph"));
     28        assertClose(40.234f, parseSpeed("25 mph"));
     29    }
    3030
    31         @Test
    32         public void testParseSpeedInvalid() {
    33                 assertNull(parseSpeed("lightspeed"));
    34         }
     31    @Test
     32    public void testParseSpeedInvalid() {
     33        assertNull(parseSpeed("lightspeed"));
     34    }
    3535
    36         /* measure */
     36    /* measure */
    3737
    38         @Test
    39         public void testParseMeasureDefault() {
    40                 assertClose(3.5f, parseMeasure("3.5"));
    41         }
     38    @Test
     39    public void testParseMeasureDefault() {
     40        assertClose(3.5f, parseMeasure("3.5"));
     41    }
    4242
    43         @Test
    44         public void testParseMeasureM() {
    45                 assertClose(2, parseMeasure("2m"));
    46                 assertClose(5.5f, parseMeasure("5.5 m"));
    47         }
     43    @Test
     44    public void testParseMeasureM() {
     45        assertClose(2, parseMeasure("2m"));
     46        assertClose(5.5f, parseMeasure("5.5 m"));
     47    }
    4848
    49         @Test
    50         public void testParseMeasureKm() {
    51                 assertClose(1000, parseMeasure("1 km"));
    52                 assertClose(7200, parseMeasure("7.2km"));
    53         }
     49    @Test
     50    public void testParseMeasureKm() {
     51        assertClose(1000, parseMeasure("1 km"));
     52        assertClose(7200, parseMeasure("7.2km"));
     53    }
    5454
    55         @Test
    56         public void testParseMeasureMi() {
    57                 assertClose(1609.344f, parseMeasure("1 mi"));
    58         }
     55    @Test
     56    public void testParseMeasureMi() {
     57        assertClose(1609.344f, parseMeasure("1 mi"));
     58    }
    5959
    60         @Test
    61         public void testParseMeasureFeetInches() {
    62                 assertClose(3.6576f, parseMeasure("12'0\""));
    63                 assertClose(1.9812f, parseMeasure("6' 6\""));
    64         }
     60    @Test
     61    public void testParseMeasureFeetInches() {
     62        assertClose(3.6576f, parseMeasure("12'0\""));
     63        assertClose(1.9812f, parseMeasure("6' 6\""));
     64    }
    6565
    66         @Test
    67         public void testParseMeasureInvalid() {
    68                 assertNull(parseMeasure("very long"));
    69                 assertNull(parseMeasure("6' 16\""));
    70         }
     66    @Test
     67    public void testParseMeasureInvalid() {
     68        assertNull(parseMeasure("very long"));
     69        assertNull(parseMeasure("6' 16\""));
     70    }
    7171
    72         /* weight */
     72    /* weight */
    7373
    74         @Test
    75         public void testParseWeightDefault() {
    76                 assertClose(3.6f, parseWeight("3.6"));
    77         }
     74    @Test
     75    public void testParseWeightDefault() {
     76        assertClose(3.6f, parseWeight("3.6"));
     77    }
    7878
    79         @Test
    80         public void testParseWeightT() {
    81                 assertClose(30, parseWeight("30t"));
    82                 assertClose(3.5f, parseWeight("3.5 t"));
    83         }
     79    @Test
     80    public void testParseWeightT() {
     81        assertClose(30, parseWeight("30t"));
     82        assertClose(3.5f, parseWeight("3.5 t"));
     83    }
    8484
    85         @Test
    86         public void testParseWeightInvalid() {
    87                 assertNull(parseWeight("heavy"));
    88         }
     85    @Test
     86    public void testParseWeightInvalid() {
     87        assertNull(parseWeight("heavy"));
     88    }
    8989
    90         private static final void assertClose(float expected, float actual) {
    91                 if (Math.abs(expected - actual) > 0.001) {
    92                         throw new AssertionError("expected " + expected + ", was " + actual);
    93                 }
    94         }
     90    private static final void assertClose(float expected, float actual) {
     91        if (Math.abs(expected - actual) > 0.001) {
     92            throw new AssertionError("expected " + expected + ", was " + actual);
     93        }
     94    }
    9595
    9696}

  • applications/editors/josm/plugins/graphview/test/org/openstreetmap/josm/plugins/graphview/core/visualisation/FloatPropertyColorSchemeTest.java

    r16520 r23189  
    1313public class FloatPropertyColorSchemeTest {
    1414
    15         private FloatPropertyColorScheme subject;
     15    private FloatPropertyColorScheme subject;
    1616
    17         @Before
    18         public void setUp() {
     17    @Before
     18    public void setUp() {
    1919
    20                 Map<Float, Color> colorMap = new HashMap<Float, Color>();
    21                 colorMap.put( 5f, new Color( 42,  42,  42));
    22                 colorMap.put(10f, new Color(100, 100, 100));
    23                 colorMap.put(20f, new Color(200, 200, 200));
     20        Map<Float, Color> colorMap = new HashMap<Float, Color>();
     21        colorMap.put( 5f, new Color( 42,  42,  42));
     22        colorMap.put(10f, new Color(100, 100, 100));
     23        colorMap.put(20f, new Color(200, 200, 200));
    2424
    25                 subject = new FloatPropertyColorScheme(RoadMaxweight.class, colorMap, Color.RED);
    26         }
     25        subject = new FloatPropertyColorScheme(RoadMaxweight.class, colorMap, Color.RED);
     26    }
    2727
    28         @Test
    29         public void testGetColorForValue_below() {
    30                 assertEquals(new Color(42, 42, 42), subject.getColorForValue(1f));
    31                 assertEquals(new Color(42, 42, 42), subject.getColorForValue(5f));
    32         }
     28    @Test
     29    public void testGetColorForValue_below() {
     30        assertEquals(new Color(42, 42, 42), subject.getColorForValue(1f));
     31        assertEquals(new Color(42, 42, 42), subject.getColorForValue(5f));
     32    }
    3333
    34         @Test
    35         public void testGetColorForValue_above() {
    36                 assertEquals(new Color(200, 200, 200), subject.getColorForValue(25f));
    37         }
     34    @Test
     35    public void testGetColorForValue_above() {
     36        assertEquals(new Color(200, 200, 200), subject.getColorForValue(25f));
     37    }
    3838
    39         @Test
    40         public void testGetColorForValue_value() {
    41                 assertEquals(new Color(100, 100, 100), subject.getColorForValue(10f));
    42         }
     39    @Test
     40    public void testGetColorForValue_value() {
     41        assertEquals(new Color(100, 100, 100), subject.getColorForValue(10f));
     42    }
    4343
    44         @Test
    45         public void testGetColorForValue_interpolate() {
    46                 assertEquals(new Color(150, 150, 150), subject.getColorForValue(15f));
    47         }
     44    @Test
     45    public void testGetColorForValue_interpolate() {
     46        assertEquals(new Color(150, 150, 150), subject.getColorForValue(15f));
     47    }
    4848
    4949}
Note: See TracChangeset for help on using the changeset viewer.