001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018 package org.apache.commons.math.geometry;
019
020 import java.text.NumberFormat;
021 import java.text.ParseException;
022 import java.text.ParsePosition;
023 import java.util.Locale;
024
025 import junit.framework.TestCase;
026
027 import org.apache.commons.math.util.CompositeFormat;
028
029 public abstract class Vector3DFormatAbstractTest extends TestCase {
030
031 Vector3DFormat vector3DFormat = null;
032 Vector3DFormat vector3DFormatSquare = null;
033
034 protected abstract Locale getLocale();
035
036 protected abstract char getDecimalCharacter();
037
038 @Override
039 protected void setUp() throws Exception {
040 vector3DFormat = Vector3DFormat.getInstance(getLocale());
041 final NumberFormat nf = NumberFormat.getInstance(getLocale());
042 nf.setMaximumFractionDigits(2);
043 vector3DFormatSquare = new Vector3DFormat("[", "]", " : ", nf);
044 }
045
046 public void testSimpleNoDecimals() {
047 Vector3D c = new Vector3D(1, 1, 1);
048 String expected = "{1; 1; 1}";
049 String actual = vector3DFormat.format(c);
050 assertEquals(expected, actual);
051 }
052
053 public void testSimpleWithDecimals() {
054 Vector3D c = new Vector3D(1.23, 1.43, 1.63);
055 String expected =
056 "{1" + getDecimalCharacter() +
057 "23; 1" + getDecimalCharacter() +
058 "43; 1" + getDecimalCharacter() +
059 "63}";
060 String actual = vector3DFormat.format(c);
061 assertEquals(expected, actual);
062 }
063
064 public void testSimpleWithDecimalsTrunc() {
065 Vector3D c = new Vector3D(1.2323, 1.4343, 1.6333);
066 String expected =
067 "{1" + getDecimalCharacter() +
068 "23; 1" + getDecimalCharacter() +
069 "43; 1" + getDecimalCharacter() +
070 "63}";
071 String actual = vector3DFormat.format(c);
072 assertEquals(expected, actual);
073 }
074
075 public void testNegativeX() {
076 Vector3D c = new Vector3D(-1.2323, 1.4343, 1.6333);
077 String expected =
078 "{-1" + getDecimalCharacter() +
079 "23; 1" + getDecimalCharacter() +
080 "43; 1" + getDecimalCharacter() +
081 "63}";
082 String actual = vector3DFormat.format(c);
083 assertEquals(expected, actual);
084 }
085
086 public void testNegativeY() {
087 Vector3D c = new Vector3D(1.2323, -1.4343, 1.6333);
088 String expected =
089 "{1" + getDecimalCharacter() +
090 "23; -1" + getDecimalCharacter() +
091 "43; 1" + getDecimalCharacter() +
092 "63}";
093 String actual = vector3DFormat.format(c);
094 assertEquals(expected, actual);
095 }
096
097 public void testNegativeZ() {
098 Vector3D c = new Vector3D(1.2323, 1.4343, -1.6333);
099 String expected =
100 "{1" + getDecimalCharacter() +
101 "23; 1" + getDecimalCharacter() +
102 "43; -1" + getDecimalCharacter() +
103 "63}";
104 String actual = vector3DFormat.format(c);
105 assertEquals(expected, actual);
106 }
107
108 public void testNonDefaultSetting() {
109 Vector3D c = new Vector3D(1, 1, 1);
110 String expected = "[1 : 1 : 1]";
111 String actual = vector3DFormatSquare.format(c);
112 assertEquals(expected, actual);
113 }
114
115 public void testStaticFormatVector3D() {
116 Locale defaultLocal = Locale.getDefault();
117 Locale.setDefault(getLocale());
118
119 Vector3D c = new Vector3D(232.222, -342.33, 432.444);
120 String expected =
121 "{232" + getDecimalCharacter() +
122 "22; -342" + getDecimalCharacter() +
123 "33; 432" + getDecimalCharacter() +
124 "44}";
125 String actual = Vector3DFormat.formatVector3D(c);
126 assertEquals(expected, actual);
127
128 Locale.setDefault(defaultLocal);
129 }
130
131 public void testNan() {
132 Vector3D c = Vector3D.NaN;
133 String expected = "{(NaN); (NaN); (NaN)}";
134 String actual = vector3DFormat.format(c);
135 assertEquals(expected, actual);
136 }
137
138 public void testPositiveInfinity() {
139 Vector3D c = Vector3D.POSITIVE_INFINITY;
140 String expected = "{(Infinity); (Infinity); (Infinity)}";
141 String actual = vector3DFormat.format(c);
142 assertEquals(expected, actual);
143 }
144
145 public void tesNegativeInfinity() {
146 Vector3D c = Vector3D.NEGATIVE_INFINITY;
147 String expected = "{(-Infinity); (-Infinity); (-Infinity)}";
148 String actual = vector3DFormat.format(c);
149 assertEquals(expected, actual);
150 }
151
152 public void testParseSimpleNoDecimals() {
153 String source = "{1; 1; 1}";
154 Vector3D expected = new Vector3D(1, 1, 1);
155 try {
156 Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
157 assertEquals(expected, actual);
158 } catch (ParseException ex) {
159 fail(ex.getMessage());
160 }
161 }
162
163 public void testParseIgnoredWhitespace() {
164 Vector3D expected = new Vector3D(1, 1, 1);
165 ParsePosition pos1 = new ParsePosition(0);
166 String source1 = "{1;1;1}";
167 assertEquals(expected, vector3DFormat.parseObject(source1, pos1));
168 assertEquals(source1.length(), pos1.getIndex());
169 ParsePosition pos2 = new ParsePosition(0);
170 String source2 = " { 1 ; 1 ; 1 } ";
171 assertEquals(expected, vector3DFormat.parseObject(source2, pos2));
172 assertEquals(source2.length() - 1, pos2.getIndex());
173 }
174
175 public void testParseSimpleWithDecimals() {
176 String source =
177 "{1" + getDecimalCharacter() +
178 "23; 1" + getDecimalCharacter() +
179 "43; 1" + getDecimalCharacter() +
180 "63}";
181 Vector3D expected = new Vector3D(1.23, 1.43, 1.63);
182 try {
183 Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
184 assertEquals(expected, actual);
185 } catch (ParseException ex) {
186 fail(ex.getMessage());
187 }
188 }
189
190 public void testParseSimpleWithDecimalsTrunc() {
191 String source =
192 "{1" + getDecimalCharacter() +
193 "2323; 1" + getDecimalCharacter() +
194 "4343; 1" + getDecimalCharacter() +
195 "6333}";
196 Vector3D expected = new Vector3D(1.2323, 1.4343, 1.6333);
197 try {
198 Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
199 assertEquals(expected, actual);
200 } catch (ParseException ex) {
201 fail(ex.getMessage());
202 }
203 }
204
205 public void testParseNegativeX() {
206 String source =
207 "{-1" + getDecimalCharacter() +
208 "2323; 1" + getDecimalCharacter() +
209 "4343; 1" + getDecimalCharacter() +
210 "6333}";
211 Vector3D expected = new Vector3D(-1.2323, 1.4343, 1.6333);
212 try {
213 Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
214 assertEquals(expected, actual);
215 } catch (ParseException ex) {
216 fail(ex.getMessage());
217 }
218 }
219
220 public void testParseNegativeY() {
221 String source =
222 "{1" + getDecimalCharacter() +
223 "2323; -1" + getDecimalCharacter() +
224 "4343; 1" + getDecimalCharacter() +
225 "6333}";
226 Vector3D expected = new Vector3D(1.2323, -1.4343, 1.6333);
227 try {
228 Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
229 assertEquals(expected, actual);
230 } catch (ParseException ex) {
231 fail(ex.getMessage());
232 }
233 }
234
235 public void testParseNegativeZ() {
236 String source =
237 "{1" + getDecimalCharacter() +
238 "2323; 1" + getDecimalCharacter() +
239 "4343; -1" + getDecimalCharacter() +
240 "6333}";
241 Vector3D expected = new Vector3D(1.2323, 1.4343, -1.6333);
242 try {
243 Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
244 assertEquals(expected, actual);
245 } catch (ParseException ex) {
246 fail(ex.getMessage());
247 }
248 }
249
250 public void testParseNegativeAll() {
251 String source =
252 "{-1" + getDecimalCharacter() +
253 "2323; -1" + getDecimalCharacter() +
254 "4343; -1" + getDecimalCharacter() +
255 "6333}";
256 Vector3D expected = new Vector3D(-1.2323, -1.4343, -1.6333);
257 try {
258 Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
259 assertEquals(expected, actual);
260 } catch (ParseException ex) {
261 fail(ex.getMessage());
262 }
263 }
264
265 public void testParseZeroX() {
266 String source =
267 "{0" + getDecimalCharacter() +
268 "0; -1" + getDecimalCharacter() +
269 "4343; 1" + getDecimalCharacter() +
270 "6333}";
271 Vector3D expected = new Vector3D(0.0, -1.4343, 1.6333);
272 try {
273 Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
274 assertEquals(expected, actual);
275 } catch (ParseException ex) {
276 fail(ex.getMessage());
277 }
278 }
279
280 public void testParseNonDefaultSetting() {
281 String source =
282 "[1" + getDecimalCharacter() +
283 "2323 : 1" + getDecimalCharacter() +
284 "4343 : 1" + getDecimalCharacter() +
285 "6333]";
286 Vector3D expected = new Vector3D(1.2323, 1.4343, 1.6333);
287 try {
288 Vector3D actual = (Vector3D) vector3DFormatSquare.parseObject(source);
289 assertEquals(expected, actual);
290 } catch (ParseException ex) {
291 fail(ex.getMessage());
292 }
293 }
294
295 public void testParseNan() {
296 String source = "{(NaN); (NaN); (NaN)}";
297 try {
298 Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
299 assertEquals(Vector3D.NaN, actual);
300 } catch (ParseException ex) {
301 fail(ex.getMessage());
302 }
303 }
304
305 public void testParsePositiveInfinity() {
306 String source = "{(Infinity); (Infinity); (Infinity)}";
307 try {
308 Vector3D actual = (Vector3D)vector3DFormat.parseObject(source);
309 assertEquals(Vector3D.POSITIVE_INFINITY, actual);
310 } catch (ParseException ex) {
311 fail(ex.getMessage());
312 }
313 }
314
315 public void testParseNegativeInfinity() {
316 String source = "{(-Infinity); (-Infinity); (-Infinity)}";
317 try {
318 Vector3D actual = (Vector3D)vector3DFormat.parseObject(source);
319 assertEquals(Vector3D.NEGATIVE_INFINITY, actual);
320 } catch (ParseException ex) {
321 fail(ex.getMessage());
322 }
323 }
324
325 public void testConstructorSingleFormat() {
326 NumberFormat nf = NumberFormat.getInstance();
327 Vector3DFormat cf = new Vector3DFormat(nf);
328 assertNotNull(cf);
329 assertEquals(nf, cf.getFormat());
330 }
331
332 public void testFormatObject() {
333 try {
334 CompositeFormat cf = new Vector3DFormat();
335 Object object = new Object();
336 cf.format(object);
337 fail();
338 } catch (IllegalArgumentException ex) {
339 // success
340 }
341 }
342
343 public void testForgottenPrefix() {
344 ParsePosition pos = new ParsePosition(0);
345 assertNull(new Vector3DFormat().parse("1; 1; 1}", pos));
346 assertEquals(0, pos.getErrorIndex());
347 }
348
349 public void testForgottenSeparator() {
350 ParsePosition pos = new ParsePosition(0);
351 assertNull(new Vector3DFormat().parse("{1; 1 1}", pos));
352 assertEquals(6, pos.getErrorIndex());
353 }
354
355 public void testForgottenSuffix() {
356 ParsePosition pos = new ParsePosition(0);
357 assertNull(new Vector3DFormat().parse("{1; 1; 1 ", pos));
358 assertEquals(8, pos.getErrorIndex());
359 }
360
361 }