← Back to branch summary

~ubuntu-branches/debian/sid/latexdraw/sid

« back to all changes in this revision

Viewing changes to junit/test/parser/svg/parsers/TestSVGPointsParser.java

  • Committer: Bazaar Package Importer
  • Author(s): Stuart Prescott
  • Date: 2009-07-15 23:35:52 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090715233552-2bblktyf2lmrkyo3
Tags: 2.0.3+1-1
http://bugs.debian.org/529195
* New upstream release.
* Add additional Recommended packages for new export features.
* Fix typo in long description, with thanks to Kai Weber (Closes: #529195).
* Bump standards to 3.8.2 (no changes).

Show diffs side-by-side

added added

removed removed

Lines of Context:
junit/test/parser/svg/parsers/TestSVGPointsParser.java
 
1
package junit.test.parser.svg.parsers;
 
2
 
 
3
import java.awt.geom.Point2D;
 
4
import java.text.ParseException;
 
5
 
 
6
import junit.test.parser.TestCodeParser;
 
7
import latexDraw.parsers.svg.parsers.SVGPointsParser;
 
8
 
 
9
import org.junit.Before;
 
10
 
 
11
public class TestSVGPointsParser extends TestCodeParser
 
12
{
 
13
        @Override
 
14
        @Before
 
15
        public void setUp()
 
16
        {
 
17
                parser  = new SVGPointsParser("");
 
18
                parser2 = new SVGPointsParser("");
 
19
        }
 
20
        
 
21
        
 
22
        
 
23
        @Override
 
24
        public void testParse()
 
25
        {
 
26
                try {
 
27
                        parser.setCode(" 1, 2, \t 3\n 4 \r ,5 6  \n \t ");
 
28
                        parser.parse();
 
29
                        assertNotNull(((SVGPointsParser)parser).getPoints());
 
30
                        assertEquals(((SVGPointsParser)parser).getPoints().firstElement(), new Point2D.Double(1., 2.));
 
31
                        assertEquals(((SVGPointsParser)parser).getPoints().elementAt(1),   new Point2D.Double(3., 4.));
 
32
                        assertEquals(((SVGPointsParser)parser).getPoints().lastElement(),  new Point2D.Double(5., 6.));
 
33
                }
 
34
                catch(ParseException e) { fail(); }
 
35
                
 
36
                try {
 
37
                        parser.setCode("dsf");
 
38
                        parser.parse();
 
39
                }catch(ParseException e) { /* */ }
 
40
                
 
41
                try {
 
42
                        parser.setCode("10 10 10");
 
43
                        parser.parse();
 
44
                }catch(ParseException e) { /* */ }
 
45
                
 
46
                try {
 
47
                        parser.setCode("10,, 10 10 10");
 
48
                        parser.parse();
 
49
                }catch(ParseException e) { /* */ }
 
50
                try {
 
51
                        parser.setCode(",10 10 10 10");
 
52
                        parser.parse();
 
53
                }catch(ParseException e) { /* */ }
 
54
                try {
 
55
                        parser.setCode("10 10 10,");
 
56
                        parser.parse();
 
57
                }catch(ParseException e) { /* */ }
 
58
                try {
 
59
                        parser.setCode("10 10 aa 10");
 
60
                        parser.parse();
 
61
                }catch(ParseException e) { /* */ }
 
62
                try {
 
63
                        parser.setCode("10 10 10e 10");
 
64
                        parser.parse();
 
65
                }catch(ParseException e) { /* */ }
 
66
                try {
 
67
                        parser.setCode("10 10E 10 10");
 
68
                        parser.parse();
 
69
                }catch(ParseException e) { /* */ }
 
70
        }
 
71
 
 
72
        @Override
 
73
        public void testSkipComment()
 
74
        {
 
75
                // No comment allowed.
 
76
        }
 
77
 
 
78
        @Override
 
79
        public void testSkipWSP()
 
80
        {
 
81
                parser.setCode(" \r  \t \n 10 10");
 
82
                parser.skipWSP();
 
83
                assertEquals(parser.getChar(), '1');
 
84
        }
 
85
        
 
86
        
 
87
        public void testIsWSP()
 
88
        {
 
89
                parser.setCode(" \r\t\na");
 
90
                assertTrue(parser.isWSP());
 
91
                parser.nextChar();
 
92
                assertTrue(parser.isWSP());
 
93
                parser.nextChar();
 
94
                assertTrue(parser.isWSP());
 
95
                parser.nextChar();
 
96
                assertTrue(parser.isWSP());
 
97
                parser.nextChar();
 
98
                assertFalse(parser.isWSP());
 
99
                parser.nextChar();
 
100
                assertFalse(parser.isWSP());
 
101
        }
 
102
        
 
103
        
 
104
        public void testSkipWSPComma()
 
105
        {
 
106
                parser.setCode(" \r , \t \n 10 10");
 
107
                ((SVGPointsParser)parser).skipWSPComma();
 
108
                assertEquals(parser.getChar(), '1');
 
109
                parser.setCode(" \r , \t \n , 10 10");
 
110
                ((SVGPointsParser)parser).skipWSPComma();
 
111
                assertEquals(parser.getChar(), ',');
 
112
        }
 
113
        
 
114
        
 
115
        public void testReadNumber()
 
116
        {
 
117
                SVGPointsParser p = (SVGPointsParser)parser;
 
118
                
 
119
                try {
 
120
                        p.setCode("10");
 
121
                        assertEquals(p.readNumber(), 10.);
 
122
                        p.setCode("+10");
 
123
                        assertEquals(p.readNumber(), 10.);
 
124
                        p.setCode("-10");
 
125
                        assertEquals(p.readNumber(), -10.);
 
126
                        p.setCode("-10.");
 
127
                        assertEquals(p.readNumber(), -10.);
 
128
                        p.setCode("-.1");
 
129
                        assertEquals(p.readNumber(), -.1);
 
130
                        p.setCode("10e2");
 
131
                        assertEquals(p.readNumber(), 1000.);
 
132
                        p.setCode("10e-2");
 
133
                        assertEquals(p.readNumber(), 0.1);
 
134
                        p.setCode("10e+2");
 
135
                        assertEquals(p.readNumber(), 1000.);
 
136
                        p.setCode("10E2");
 
137
                        assertEquals(p.readNumber(), 1000.);
 
138
                        p.setCode("10E-2");
 
139
                        assertEquals(p.readNumber(), 0.1);
 
140
                        p.setCode("10E+2");
 
141
                        assertEquals(p.readNumber(), 1000.);
 
142
                        p.setCode("0.E+2");
 
143
                        assertEquals(p.readNumber(), 0.);
 
144
                }
 
145
                catch(ParseException e) { e.printStackTrace(); fail(); }
 
146
                
 
147
                try {
 
148
                        p.setCode(".E+2");
 
149
                        assertEquals(p.readNumber(), 0.);
 
150
                } catch(ParseException e) { /* */}
 
151
                try {
 
152
                        p.setCode(".Efd+2");
 
153
                        assertEquals(p.readNumber(), 0.);
 
154
                } catch(ParseException e) { /* */}
 
155
                try {
 
156
                        p.setCode("");
 
157
                        assertEquals(p.readNumber(), 0.);
 
158
                } catch(ParseException e) { /* */}
 
159
                try {
 
160
                        p.setCode(" \t");
 
161
                        assertEquals(p.readNumber(), 0.);
 
162
                } catch(ParseException e) { /* */}
 
163
                try {
 
164
                        p.setCode("aa");
 
165
                        assertEquals(p.readNumber(), 0.);
 
166
                } catch(ParseException e) { /* */}
 
167
                try {
 
168
                        p.setCode(".");
 
169
                        assertEquals(p.readNumber(), 0.);
 
170
                } catch(ParseException e) { /* */}
 
171
                try {
 
172
                        p.setCode("--10");
 
173
                        assertEquals(p.readNumber(), 0.);
 
174
                } catch(ParseException e) { /* */}
 
175
                try {
 
176
                        p.setCode("+-10");
 
177
                        assertEquals(p.readNumber(), 0.);
 
178
                } catch(ParseException e) { /* */}
 
179
        }
 
180
        
 
181
        
 
182
        public void testGetPoints()
 
183
        {
 
184
                try {
 
185
                        parser.setCode(" 1, 2,3 4 5,6");
 
186
                        parser.parse();
 
187
                        assertNotNull(((SVGPointsParser)parser).getPoints());
 
188
                        assertEquals(((SVGPointsParser)parser).getPoints().firstElement(), new Point2D.Double(1., 2.));
 
189
                        assertEquals(((SVGPointsParser)parser).getPoints().elementAt(1),   new Point2D.Double(3., 4.));
 
190
                        assertEquals(((SVGPointsParser)parser).getPoints().lastElement(),  new Point2D.Double(5., 6.));
 
191
                }
 
192
                catch(ParseException e) { fail(); }
 
193
        }
 
194
}