← Back to branch summary

~ubuntu-branches/ubuntu/quantal/commons-math/quantal

« back to all changes in this revision

Viewing changes to src/test/java/org/apache/commons/math/geometry/Vector3DFormatAbstractTest.java

  • Committer: Bazaar Package Importer
  • Author(s): Damien Raude-Morvan
  • Date: 2010-04-05 23:33:02 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100405233302-gpqlceked76nw28a
Tags: 2.1-1
* New upstream release.
* Bump Standards-Version to 3.8.4: no changes needed
* Bump debhelper to >= 7
* Switch to 3.0 (quilt) source format:
  - Remove B-D on quilt
  - Add d/source/format
  - Remove d/README.source

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/java/org/apache/commons/math/geometry/Vector3DFormatAbstractTest.java
5
5
 * The ASF licenses this file to You under the Apache License, Version 2.0
6
6
 * (the "License"); you may not use this file except in compliance with
7
7
 * the License.  You may obtain a copy of the License at
8
 
 * 
 
8
 *
9
9
 *      http://www.apache.org/licenses/LICENSE-2.0
10
 
 * 
 
10
 *
11
11
 * Unless required by applicable law or agreed to in writing, software
12
12
 * distributed under the License is distributed on an "AS IS" BASIS,
13
13
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
27
27
import org.apache.commons.math.util.CompositeFormat;
28
28
 
29
29
public abstract class Vector3DFormatAbstractTest extends TestCase {
30
 
 
 
30
 
31
31
    Vector3DFormat vector3DFormat = null;
32
32
    Vector3DFormat vector3DFormatSquare = null;
33
33
 
42
42
        nf.setMaximumFractionDigits(2);
43
43
        vector3DFormatSquare = new Vector3DFormat("[", "]", " : ", nf);
44
44
    }
45
 
   
 
45
 
46
46
    public void testSimpleNoDecimals() {
47
47
        Vector3D c = new Vector3D(1, 1, 1);
48
48
        String expected = "{1; 1; 1}";
49
 
        String actual = vector3DFormat.format(c); 
 
49
        String actual = vector3DFormat.format(c);
50
50
        assertEquals(expected, actual);
51
51
    }
52
52
 
57
57
            "23; 1" + getDecimalCharacter() +
58
58
            "43; 1" + getDecimalCharacter() +
59
59
            "63}";
60
 
        String actual = vector3DFormat.format(c); 
 
60
        String actual = vector3DFormat.format(c);
61
61
        assertEquals(expected, actual);
62
62
    }
63
63
 
68
68
            "23; 1" + getDecimalCharacter() +
69
69
            "43; 1" + getDecimalCharacter() +
70
70
            "63}";
71
 
        String actual = vector3DFormat.format(c); 
 
71
        String actual = vector3DFormat.format(c);
72
72
        assertEquals(expected, actual);
73
73
    }
74
74
 
79
79
            "23; 1" + getDecimalCharacter() +
80
80
            "43; 1" + getDecimalCharacter() +
81
81
            "63}";
82
 
        String actual = vector3DFormat.format(c); 
 
82
        String actual = vector3DFormat.format(c);
83
83
        assertEquals(expected, actual);
84
84
    }
85
85
 
90
90
            "23; -1" + getDecimalCharacter() +
91
91
            "43; 1" + getDecimalCharacter() +
92
92
            "63}";
93
 
        String actual = vector3DFormat.format(c); 
 
93
        String actual = vector3DFormat.format(c);
94
94
        assertEquals(expected, actual);
95
95
    }
96
96
 
101
101
            "23; 1" + getDecimalCharacter() +
102
102
            "43; -1" + getDecimalCharacter() +
103
103
            "63}";
104
 
        String actual = vector3DFormat.format(c); 
 
104
        String actual = vector3DFormat.format(c);
105
105
        assertEquals(expected, actual);
106
106
    }
107
107
 
108
108
    public void testNonDefaultSetting() {
109
109
        Vector3D c = new Vector3D(1, 1, 1);
110
110
        String expected = "[1 : 1 : 1]";
111
 
        String actual = vector3DFormatSquare.format(c); 
 
111
        String actual = vector3DFormatSquare.format(c);
112
112
        assertEquals(expected, actual);
113
113
    }
114
 
    
 
114
 
115
115
    public void testStaticFormatVector3D() {
116
116
        Locale defaultLocal = Locale.getDefault();
117
117
        Locale.setDefault(getLocale());
118
 
        
 
118
 
119
119
        Vector3D c = new Vector3D(232.222, -342.33, 432.444);
120
120
        String expected =
121
121
            "{232"    + getDecimalCharacter() +
122
122
            "22; -342" + getDecimalCharacter() +
123
123
            "33; 432" + getDecimalCharacter() +
124
124
            "44}";
125
 
        String actual = Vector3DFormat.formatVector3D(c); 
 
125
        String actual = Vector3DFormat.formatVector3D(c);
126
126
        assertEquals(expected, actual);
127
 
        
 
127
 
128
128
        Locale.setDefault(defaultLocal);
129
129
    }
130
130
 
131
131
    public void testNan() {
132
132
        Vector3D c = Vector3D.NaN;
133
133
        String expected = "{(NaN); (NaN); (NaN)}";
134
 
        String actual = vector3DFormat.format(c); 
 
134
        String actual = vector3DFormat.format(c);
135
135
        assertEquals(expected, actual);
136
136
    }
137
137
 
138
138
    public void testPositiveInfinity() {
139
139
        Vector3D c = Vector3D.POSITIVE_INFINITY;
140
140
        String expected = "{(Infinity); (Infinity); (Infinity)}";
141
 
        String actual = vector3DFormat.format(c); 
 
141
        String actual = vector3DFormat.format(c);
142
142
        assertEquals(expected, actual);
143
143
    }
144
144
 
145
145
    public void tesNegativeInfinity() {
146
146
        Vector3D c = Vector3D.NEGATIVE_INFINITY;
147
147
        String expected = "{(-Infinity); (-Infinity); (-Infinity)}";
148
 
        String actual = vector3DFormat.format(c); 
 
148
        String actual = vector3DFormat.format(c);
149
149
        assertEquals(expected, actual);
150
150
    }
151
151
 
153
153
        String source = "{1; 1; 1}";
154
154
        Vector3D expected = new Vector3D(1, 1, 1);
155
155
        try {
156
 
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source); 
 
156
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
157
157
            assertEquals(expected, actual);
158
158
        } catch (ParseException ex) {
159
159
            fail(ex.getMessage());
180
180
            "63}";
181
181
        Vector3D expected = new Vector3D(1.23, 1.43, 1.63);
182
182
        try {
183
 
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source); 
 
183
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
184
184
            assertEquals(expected, actual);
185
185
        } catch (ParseException ex) {
186
186
            fail(ex.getMessage());
195
195
            "6333}";
196
196
        Vector3D expected = new Vector3D(1.2323, 1.4343, 1.6333);
197
197
        try {
198
 
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source); 
 
198
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
199
199
            assertEquals(expected, actual);
200
200
        } catch (ParseException ex) {
201
201
            fail(ex.getMessage());
210
210
            "6333}";
211
211
        Vector3D expected = new Vector3D(-1.2323, 1.4343, 1.6333);
212
212
        try {
213
 
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source); 
 
213
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
214
214
            assertEquals(expected, actual);
215
215
        } catch (ParseException ex) {
216
216
            fail(ex.getMessage());
225
225
            "6333}";
226
226
        Vector3D expected = new Vector3D(1.2323, -1.4343, 1.6333);
227
227
        try {
228
 
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source); 
 
228
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
229
229
            assertEquals(expected, actual);
230
230
        } catch (ParseException ex) {
231
231
            fail(ex.getMessage());
240
240
            "6333}";
241
241
        Vector3D expected = new Vector3D(1.2323, 1.4343, -1.6333);
242
242
        try {
243
 
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source); 
 
243
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
244
244
            assertEquals(expected, actual);
245
245
        } catch (ParseException ex) {
246
246
            fail(ex.getMessage());
255
255
            "6333}";
256
256
        Vector3D expected = new Vector3D(-1.2323, -1.4343, -1.6333);
257
257
        try {
258
 
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source); 
 
258
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
259
259
            assertEquals(expected, actual);
260
260
        } catch (ParseException ex) {
261
261
            fail(ex.getMessage());
270
270
            "6333}";
271
271
        Vector3D expected = new Vector3D(0.0, -1.4343, 1.6333);
272
272
        try {
273
 
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source); 
 
273
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
274
274
            assertEquals(expected, actual);
275
275
        } catch (ParseException ex) {
276
276
            fail(ex.getMessage());
285
285
            "6333]";
286
286
        Vector3D expected = new Vector3D(1.2323, 1.4343, 1.6333);
287
287
        try {
288
 
            Vector3D actual = (Vector3D) vector3DFormatSquare.parseObject(source); 
 
288
            Vector3D actual = (Vector3D) vector3DFormatSquare.parseObject(source);
289
289
            assertEquals(expected, actual);
290
290
        } catch (ParseException ex) {
291
291
            fail(ex.getMessage());
292
292
        }
293
293
    }
294
 
    
 
294
 
295
295
    public void testParseNan() {
296
296
        String source = "{(NaN); (NaN); (NaN)}";
297
297
        try {
298
 
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source); 
 
298
            Vector3D actual = (Vector3D) vector3DFormat.parseObject(source);
299
299
            assertEquals(Vector3D.NaN, actual);
300
300
        } catch (ParseException ex) {
301
301
            fail(ex.getMessage());
305
305
    public void testParsePositiveInfinity() {
306
306
        String source = "{(Infinity); (Infinity); (Infinity)}";
307
307
        try {
308
 
            Vector3D actual = (Vector3D)vector3DFormat.parseObject(source); 
 
308
            Vector3D actual = (Vector3D)vector3DFormat.parseObject(source);
309
309
            assertEquals(Vector3D.POSITIVE_INFINITY, actual);
310
310
        } catch (ParseException ex) {
311
311
            fail(ex.getMessage());
315
315
    public void testParseNegativeInfinity() {
316
316
        String source = "{(-Infinity); (-Infinity); (-Infinity)}";
317
317
        try {
318
 
            Vector3D actual = (Vector3D)vector3DFormat.parseObject(source); 
 
318
            Vector3D actual = (Vector3D)vector3DFormat.parseObject(source);
319
319
            assertEquals(Vector3D.NEGATIVE_INFINITY, actual);
320
320
        } catch (ParseException ex) {
321
321
            fail(ex.getMessage());
328
328
        assertNotNull(cf);
329
329
        assertEquals(nf, cf.getFormat());
330
330
    }
331
 
    
 
331
 
332
332
    public void testFormatObject() {
333
333
        try {
334
334
            CompositeFormat cf = new Vector3DFormat();