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