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.fraction;
019    
020    import java.text.NumberFormat;
021    import java.text.ParseException;
022    import java.util.Locale;
023    
024    import junit.framework.TestCase;
025    
026    public class FractionFormatTest extends TestCase {
027     
028        FractionFormat properFormat = null;
029        FractionFormat improperFormat = null;
030    
031        protected Locale getLocale() {
032            return Locale.getDefault();
033        }
034    
035        @Override
036        protected void setUp() throws Exception {
037            properFormat = FractionFormat.getProperInstance(getLocale());
038            improperFormat = FractionFormat.getImproperInstance(getLocale());
039        }
040       
041        public void testFormat() {
042            Fraction c = new Fraction(1, 2);
043            String expected = "1 / 2";
044            
045            String actual = properFormat.format(c); 
046            assertEquals(expected, actual);
047    
048            actual = improperFormat.format(c);
049            assertEquals(expected, actual);
050        }
051    
052        public void testFormatNegative() {
053            Fraction c = new Fraction(-1, 2);
054            String expected = "-1 / 2";
055    
056            String actual = properFormat.format(c); 
057            assertEquals(expected, actual);
058    
059            actual = improperFormat.format(c); 
060            assertEquals(expected, actual);
061        }
062    
063        public void testFormatZero() {
064            Fraction c = new Fraction(0, 1);
065            String expected = "0 / 1";
066    
067            String actual = properFormat.format(c); 
068            assertEquals(expected, actual);
069    
070            actual = improperFormat.format(c); 
071            assertEquals(expected, actual);
072        }
073        
074        public void testFormatImproper() {
075            Fraction c = new Fraction(5, 3);
076    
077            String actual = properFormat.format(c); 
078            assertEquals("1 2 / 3", actual);
079    
080            actual = improperFormat.format(c); 
081            assertEquals("5 / 3", actual);
082        }
083        
084        public void testFormatImproperNegative() {
085            Fraction c = new Fraction(-5, 3);
086    
087            String actual = properFormat.format(c); 
088            assertEquals("-1 2 / 3", actual);
089    
090            actual = improperFormat.format(c); 
091            assertEquals("-5 / 3", actual);
092        }
093        
094        public void testParse() {
095            String source = "1 / 2";
096    
097            try {
098                Fraction c = properFormat.parse(source);
099                assertNotNull(c);
100                assertEquals(1, c.getNumerator());
101                assertEquals(2, c.getDenominator());
102                
103                c = improperFormat.parse(source);
104                assertNotNull(c);
105                assertEquals(1, c.getNumerator());
106                assertEquals(2, c.getDenominator());
107            } catch (ParseException ex) {
108                fail(ex.getMessage());
109            }
110        }
111        
112        public void testParseInteger() {
113            String source = "10";
114            try {
115                Fraction c = properFormat.parse(source);
116                assertNotNull(c);
117                assertEquals(10, c.getNumerator());
118                assertEquals(1, c.getDenominator());
119            } catch (ParseException ex) {
120                fail(ex.getMessage());
121            }
122            try {
123                Fraction c = improperFormat.parse(source);
124                assertNotNull(c);
125                assertEquals(10, c.getNumerator());
126                assertEquals(1, c.getDenominator());
127            } catch (ParseException ex) {
128                fail(ex.getMessage());
129            }
130        }
131        
132        public void testParseInvalid() {
133            String source = "a";
134            String msg = "should not be able to parse '10 / a'.";
135            try {
136                properFormat.parse(source);
137                fail(msg);
138            } catch (ParseException ex) {
139                // success
140            }
141            try {
142                improperFormat.parse(source);
143                fail(msg);
144            } catch (ParseException ex) {
145                // success
146            }
147        }
148        
149        public void testParseInvalidDenominator() {
150            String source = "10 / a";
151            String msg = "should not be able to parse '10 / a'.";
152            try {
153                properFormat.parse(source);
154                fail(msg);
155            } catch (ParseException ex) {
156                // success
157            }
158            try {
159                improperFormat.parse(source);
160                fail(msg);
161            } catch (ParseException ex) {
162                // success
163            }
164        }
165        
166        public void testParseNegative() {
167    
168            try {
169                String source = "-1 / 2";
170                Fraction c = properFormat.parse(source);
171                assertNotNull(c);
172                assertEquals(-1, c.getNumerator());
173                assertEquals(2, c.getDenominator());
174                
175                c = improperFormat.parse(source);
176                assertNotNull(c);
177                assertEquals(-1, c.getNumerator());
178                assertEquals(2, c.getDenominator());
179    
180                source = "1 / -2";
181                c = properFormat.parse(source);
182                assertNotNull(c);
183                assertEquals(-1, c.getNumerator());
184                assertEquals(2, c.getDenominator());
185                
186                c = improperFormat.parse(source);
187                assertNotNull(c);
188                assertEquals(-1, c.getNumerator());
189                assertEquals(2, c.getDenominator());
190            } catch (ParseException ex) {
191                fail(ex.getMessage());
192            }
193        }
194        
195        public void testParseProper() {
196            String source = "1 2 / 3";
197    
198            try {
199                Fraction c = properFormat.parse(source);
200                assertNotNull(c);
201                assertEquals(5, c.getNumerator());
202                assertEquals(3, c.getDenominator());
203            } catch (ParseException ex) {
204                fail(ex.getMessage());
205            }
206            
207            try {
208                improperFormat.parse(source);
209                fail("invalid improper fraction.");
210            } catch (ParseException ex) {
211                // success
212            }
213        }
214        
215        public void testParseProperNegative() {
216            String source = "-1 2 / 3";
217            try {
218                Fraction c = properFormat.parse(source);
219                assertNotNull(c);
220                assertEquals(-5, c.getNumerator());
221                assertEquals(3, c.getDenominator());
222            } catch (ParseException ex) {
223                fail(ex.getMessage());
224            }
225            
226            try {
227                improperFormat.parse(source);
228                fail("invalid improper fraction.");
229            } catch (ParseException ex) {
230                // success
231            }
232        }
233        
234        public void testParseProperInvalidMinus() {
235            String source = "2 -2 / 3";
236            try {
237                properFormat.parse(source);
238                fail("invalid minus in improper fraction.");
239            } catch (ParseException ex) {
240                // expected
241            }
242            source = "2 2 / -3";
243            try {
244                properFormat.parse(source);
245                fail("invalid minus in improper fraction.");
246            } catch (ParseException ex) {
247                // expected
248            }
249        }
250        
251        public void testNumeratorFormat() {
252            NumberFormat old = properFormat.getNumeratorFormat();
253            NumberFormat nf = NumberFormat.getInstance();
254            nf.setParseIntegerOnly(true);
255            properFormat.setNumeratorFormat(nf);
256            assertEquals(nf, properFormat.getNumeratorFormat());
257            properFormat.setNumeratorFormat(old);
258    
259            old = improperFormat.getNumeratorFormat();
260            nf = NumberFormat.getInstance();
261            nf.setParseIntegerOnly(true);
262            improperFormat.setNumeratorFormat(nf);
263            assertEquals(nf, improperFormat.getNumeratorFormat());
264            improperFormat.setNumeratorFormat(old);
265        }
266        
267        public void testDenominatorFormat() {
268            NumberFormat old = properFormat.getDenominatorFormat();
269            NumberFormat nf = NumberFormat.getInstance();
270            nf.setParseIntegerOnly(true);
271            properFormat.setDenominatorFormat(nf);
272            assertEquals(nf, properFormat.getDenominatorFormat());
273            properFormat.setDenominatorFormat(old);
274    
275            old = improperFormat.getDenominatorFormat();
276            nf = NumberFormat.getInstance();
277            nf.setParseIntegerOnly(true);
278            improperFormat.setDenominatorFormat(nf);
279            assertEquals(nf, improperFormat.getDenominatorFormat());
280            improperFormat.setDenominatorFormat(old);
281        }
282        
283        public void testWholeFormat() {
284            ProperFractionFormat format = (ProperFractionFormat)properFormat;
285            
286            NumberFormat old = format.getWholeFormat();
287            NumberFormat nf = NumberFormat.getInstance();
288            nf.setParseIntegerOnly(true);
289            format.setWholeFormat(nf);
290            assertEquals(nf, format.getWholeFormat());
291            format.setWholeFormat(old);
292        }
293        
294        public void testLongFormat() {
295            assertEquals("10 / 1", improperFormat.format(10l));
296        }
297        
298        public void testDoubleFormat() {
299            assertEquals("355 / 113", improperFormat.format(Math.PI));
300        }
301    }