1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.orekit.utils.units;
18
19 import org.hipparchus.fraction.Fraction;
20 import org.junit.Assert;
21 import org.junit.Test;
22 import org.orekit.errors.OrekitException;
23 import org.orekit.errors.OrekitMessages;
24
25
26
27
28
29
30 public class LexerTest {
31
32 @Test
33 public void testAllTypes() {
34 final Lexer lexer = new Lexer("√kg*km** (3/2) /(µs^2*Ω⁻⁷)");
35 expect(lexer, "√", TokenType.SQUARE_ROOT, 0, 1);
36 expect(lexer, "kg", TokenType.IDENTIFIER, 0, 1);
37 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
38 expect(lexer, "km", TokenType.IDENTIFIER, 0, 1);
39 expect(lexer, "**", TokenType.POWER, 0, 1);
40 expect(lexer, "(", TokenType.OPEN, 0, 1);
41 expect(lexer, "3", TokenType.INTEGER, 3, 1);
42 expect(lexer, "/", TokenType.DIVISION, 0, 1);
43 expect(lexer, "2", TokenType.INTEGER, 2, 1);
44 expect(lexer, ")", TokenType.CLOSE, 0, 1);
45 expect(lexer, "/", TokenType.DIVISION, 0, 1);
46 expect(lexer, "(", TokenType.OPEN, 0, 1);
47 expect(lexer, "µs", TokenType.IDENTIFIER, 0, 1);
48 expect(lexer, "^", TokenType.POWER, 0, 1);
49 expect(lexer, "2", TokenType.INTEGER, 2, 1);
50 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
51 expect(lexer, "Ω", TokenType.IDENTIFIER, 0, 1);
52 expect(lexer, "", TokenType.POWER, 0, 1);
53 expect(lexer, "⁻⁷", TokenType.INTEGER, -7, 1);
54 expect(lexer, ")", TokenType.CLOSE, 0, 1);
55 Assert.assertNull(lexer.next());
56 }
57
58 @Test
59 public void testRegularExponent() {
60 final Lexer lexer = new Lexer("N^123450 × MHz^-98765");
61 expect(lexer, "N", TokenType.IDENTIFIER, 0, 1);
62 expect(lexer, "^", TokenType.POWER, 0, 1);
63 expect(lexer, "123450", TokenType.INTEGER, 123450, 1);
64 expect(lexer, "×", TokenType.MULTIPLICATION, 0, 1);
65 expect(lexer, "MHz", TokenType.IDENTIFIER, 0, 1);
66 expect(lexer, "^", TokenType.POWER, 0, 1);
67 expect(lexer, "-98765", TokenType.INTEGER, -98765, 1);
68 Assert.assertNull(lexer.next());
69 }
70
71 @Test
72 public void testSuperscriptExponent() {
73 final Lexer lexer = new Lexer("SFU⁺¹²³⁴⁵⁰ ⁄ mas⁻⁹⁸⁷⁶⁵");
74 expect(lexer, "SFU", TokenType.IDENTIFIER, 0, 1);
75 expect(lexer, "", TokenType.POWER, 0, 1);
76 expect(lexer, "⁺¹²³⁴⁵⁰", TokenType.INTEGER, 123450, 1);
77 expect(lexer, "⁄", TokenType.DIVISION, 0, 1);
78 expect(lexer, "mas", TokenType.IDENTIFIER, 0, 1);
79 expect(lexer, "", TokenType.POWER, 0, 1);
80 expect(lexer, "⁻⁹⁸⁷⁶⁵", TokenType.INTEGER, -98765, 1);
81 Assert.assertNull(lexer.next());
82 }
83
84 @Test
85 public void testSignWithoutDigits() {
86 final Lexer lexer = new Lexer("Pa⁻");
87 expect(lexer, "Pa", TokenType.IDENTIFIER, 0, 1);
88 expect(lexer, "", TokenType.POWER, 0, 1);
89 expectFailure(lexer);
90 }
91
92 @Test
93 public void testMultipleSigns() {
94 final Lexer lexer = new Lexer("MJ⁻⁺²");
95 expect(lexer, "MJ", TokenType.IDENTIFIER, 0, 1);
96 expect(lexer, "", TokenType.POWER, 0, 1);
97 expectFailure(lexer);
98 }
99
100 @Test
101 public void testUnknownCharacter() {
102 final Lexer lexer = new Lexer("pW^2∇");
103 expect(lexer, "pW", TokenType.IDENTIFIER, 0, 1);
104 expect(lexer, "^", TokenType.POWER, 0, 1);
105 expect(lexer, "2", TokenType.INTEGER, 2, 1);
106 expectFailure(lexer);
107 }
108
109 @Test
110 public void testPercentageCharacter() {
111 final Lexer lexer = new Lexer("%");
112 expect(lexer, "%", TokenType.IDENTIFIER, 0, 1);
113 Assert.assertNull(lexer.next());
114 }
115
116 @Test
117 public void testStartWithSuperscript() {
118 final Lexer lexer = new Lexer("³");
119 expect(lexer, "³", TokenType.INTEGER, 3, 1);
120 Assert.assertNull(lexer.next());
121 }
122
123 @Test
124 public void testCharacters() {
125 final Lexer lexer = new Lexer("d*°*min*◦*deg*′*hh*'*ad*″*a*\"*µ''");
126 expect(lexer, "d", TokenType.IDENTIFIER, 0, 1);
127 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
128 expect(lexer, "°", TokenType.IDENTIFIER, 0, 1);
129 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
130 expect(lexer, "min", TokenType.IDENTIFIER, 0, 1);
131 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
132 expect(lexer, "◦", TokenType.IDENTIFIER, 0, 1);
133 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
134 expect(lexer, "deg", TokenType.IDENTIFIER, 0, 1);
135 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
136 expect(lexer, "′", TokenType.IDENTIFIER, 0, 1);
137 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
138 expect(lexer, "hh", TokenType.IDENTIFIER, 0, 1);
139 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
140 expect(lexer, "'", TokenType.IDENTIFIER, 0, 1);
141 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
142 expect(lexer, "ad", TokenType.IDENTIFIER, 0, 1);
143 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
144 expect(lexer, "″", TokenType.IDENTIFIER, 0, 1);
145 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
146 expect(lexer, "a", TokenType.IDENTIFIER, 0, 1);
147 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
148 expect(lexer, "\"", TokenType.IDENTIFIER, 0, 1);
149 expect(lexer, "*", TokenType.MULTIPLICATION, 0, 1);
150 expect(lexer, "µ''", TokenType.IDENTIFIER, 0, 1);
151 Assert.assertNull(lexer.next());
152 }
153
154 @Test
155 public void testIdentifierUnicodeLetter() {
156 final String s = "αβγDEFghi";
157 final Lexer lexer = new Lexer(s);
158 expect(lexer, s, TokenType.IDENTIFIER, 0, 1);
159 Assert.assertNull(lexer.next());
160 }
161
162 @Test
163 public void testOneHalfAsDecimal() {
164 final Lexer lexer = new Lexer("0.5");
165 expect(lexer, "0.5", TokenType.FRACTION, 1, 2);
166 Assert.assertNull(lexer.next());
167 }
168
169 @Test
170 public void testUnicodeFractions() {
171 final Lexer lexer = new Lexer("¼½¾⅐⅑⅒⅓⅔⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞");
172 expect(lexer, "¼", TokenType.FRACTION, 1, 4);
173 expect(lexer, "½", TokenType.FRACTION, 1, 2);
174 expect(lexer, "¾", TokenType.FRACTION, 3, 4);
175 expect(lexer, "⅐", TokenType.FRACTION, 1, 7);
176 expect(lexer, "⅑", TokenType.FRACTION, 1, 9);
177 expect(lexer, "⅒", TokenType.FRACTION, 1, 10);
178 expect(lexer, "⅓", TokenType.FRACTION, 1, 3);
179 expect(lexer, "⅔", TokenType.FRACTION, 2, 3);
180 expect(lexer, "⅕", TokenType.FRACTION, 1, 5);
181 expect(lexer, "⅖", TokenType.FRACTION, 2, 5);
182 expect(lexer, "⅗", TokenType.FRACTION, 3, 5);
183 expect(lexer, "⅘", TokenType.FRACTION, 4, 5);
184 expect(lexer, "⅙", TokenType.FRACTION, 1, 6);
185 expect(lexer, "⅚", TokenType.FRACTION, 5, 6);
186 expect(lexer, "⅛", TokenType.FRACTION, 1, 8);
187 expect(lexer, "⅜", TokenType.FRACTION, 3, 8);
188 expect(lexer, "⅝", TokenType.FRACTION, 5, 8);
189 expect(lexer, "⅞", TokenType.FRACTION, 7, 8);
190 Assert.assertNull(lexer.next());
191 }
192
193 @Test
194 public void testPushBack() {
195 final Lexer lexer = new Lexer("m/s");
196 expect(lexer, "m", TokenType.IDENTIFIER, 0, 1);
197 expect(lexer, "/", TokenType.DIVISION, 0, 1);
198 lexer.pushBack();
199 expect(lexer, "/", TokenType.DIVISION, 0, 1);
200 expect(lexer, "s", TokenType.IDENTIFIER, 0, 1);
201 }
202
203 @Test
204 public void testPushBackBeforeVirtualExponent() {
205 final Lexer lexer = new Lexer("m²/s");
206 expect(lexer, "m", TokenType.IDENTIFIER, 0, 1);
207 lexer.pushBack();
208 expect(lexer, "m", TokenType.IDENTIFIER, 0, 1);
209 expect(lexer, "", TokenType.POWER, 0, 1);
210 expect(lexer, "²", TokenType.INTEGER, 2, 1);
211 expect(lexer, "/", TokenType.DIVISION, 0, 1);
212 expect(lexer, "s", TokenType.IDENTIFIER, 0, 1);
213 }
214
215 @Test
216 public void testPushBackAtVirtualExponent() {
217 final Lexer lexer = new Lexer("m²/s");
218 expect(lexer, "m", TokenType.IDENTIFIER, 0, 1);
219 expect(lexer, "", TokenType.POWER, 0, 1);
220 lexer.pushBack();
221 expect(lexer, "", TokenType.POWER, 0, 1);
222 expect(lexer, "²", TokenType.INTEGER, 2, 1);
223 expect(lexer, "/", TokenType.DIVISION, 0, 1);
224 expect(lexer, "s", TokenType.IDENTIFIER, 0, 1);
225 }
226
227 @Test
228 public void testPushBackAfterVirtualExponent() {
229 final Lexer lexer = new Lexer("m²/s");
230 expect(lexer, "m", TokenType.IDENTIFIER, 0, 1);
231 expect(lexer, "", TokenType.POWER, 0, 1);
232 expect(lexer, "²", TokenType.INTEGER, 2, 1);
233 lexer.pushBack();
234 expect(lexer, "²", TokenType.INTEGER, 2, 1);
235 expect(lexer, "/", TokenType.DIVISION, 0, 1);
236 expect(lexer, "s", TokenType.IDENTIFIER, 0, 1);
237 }
238
239 @Test
240 public void testPushBackAtEnd() {
241 final Lexer lexer = new Lexer("m²/s");
242 expect(lexer, "m", TokenType.IDENTIFIER, 0, 1);
243 expect(lexer, "", TokenType.POWER, 0, 1);
244 expect(lexer, "²", TokenType.INTEGER, 2, 1);
245 expect(lexer, "/", TokenType.DIVISION, 0, 1);
246 expect(lexer, "s", TokenType.IDENTIFIER, 0, 1);
247 Assert.assertNull(lexer.next());
248 lexer.pushBack();
249 Assert.assertNull(lexer.next());
250 }
251
252 private void expect(Lexer lexer, String subString, TokenType type,
253 int numerator, int denominator) {
254 Token t = lexer.next();
255 Assert.assertEquals(subString, t.getSubString());
256 Assert.assertEquals(type, t.getType());
257 Assert.assertEquals(numerator, t.getInt());
258 Assert.assertEquals(type == TokenType.FRACTION ? new Fraction(numerator, denominator) : null,
259 t.getFraction());
260 }
261
262 private void expectFailure(Lexer lexer) {
263 try {
264 lexer.next();
265 Assert.fail("an exception should have been thrown");
266 } catch (OrekitException oe) {
267 Assert.assertEquals(OrekitMessages.UNKNOWN_UNIT, oe.getSpecifier());
268 Assert.assertEquals(lexer.getUnitSpecification(), oe.getParts()[0]);
269 }
270 }
271
272 }