    1   /*
    2    * Copyright 2004 The Apache Software Foundation.
    3    *
    4    * Licensed under the Apache License, Version 2.0 (the "License");
    5    * you may not use this file except in compliance with the License.
    6    * You may obtain a copy of the License at
    7    *
    8    *      http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16
    17  package org.apache.commons.math.complex;
    18
    19  import java.text.NumberFormat;
    20  import java.text.ParseException;
    21  import java.util.Locale;
    22
    23  import junit.framework.TestCase;
    24
    25  public abstract class ComplexFormatAbstractTest extends TestCase {
    26
    27  	ComplexFormat complexFormat = null;
    28  	ComplexFormat complexFormatJ = null;
    29
    30      protected abstract Locale getLocale();
    31
    32      protected abstract char getDecimalCharacter();
    33
    34  	protected void setUp() throws Exception {
    35  		complexFormat = ComplexFormat.getInstance(getLocale());
    36  		complexFormatJ = ComplexFormat.getInstance(getLocale());
    37          complexFormatJ.setImaginaryCharacter("j");
    38  	}
    39
    40      public void testSimpleNoDecimals() {
    41          Complex c = new Complex(1, 1);
    42          String expected = "1 + 1i";
    43          String actual = complexFormat.format(c);
    44          assertEquals(expected, actual);
    45      }
    46
    47  	public void testSimpleWithDecimals() {
    48  		Complex c = new Complex(1.23, 1.43);
    49          String expected = "1" + getDecimalCharacter() + "23 + 1" + getDecimalCharacter() + "43i";
    50          String actual = complexFormat.format(c);
    51          assertEquals(expected, actual);
    52  	}
    53
    54  	public void testSimpleWithDecimalsTrunc() {
    55  		Complex c = new Complex(1.2323, 1.4343);
    56          String expected = "1" + getDecimalCharacter() + "23 + 1" + getDecimalCharacter() + "43i";
    57          String actual = complexFormat.format(c);
    58          assertEquals(expected, actual);
    59  	}
    60
    61  	public void testNegativeReal() {
    62  		Complex c = new Complex(-1.2323, 1.4343);
    63          String expected = "-1" + getDecimalCharacter() + "23 + 1" + getDecimalCharacter() + "43i";
    64          String actual = complexFormat.format(c);
    65          assertEquals(expected, actual);
    66  	}
    67
    68  	public void testNegativeImaginary() {
    69  		Complex c = new Complex(1.2323, -1.4343);
    70          String expected = "1" + getDecimalCharacter() + "23 - 1" + getDecimalCharacter() + "43i";
    71          String actual = complexFormat.format(c);
    72          assertEquals(expected, actual);
    73  	}
    74
    75  	public void testNegativeBoth() {
    76  		Complex c = new Complex(-1.2323, -1.4343);
    77          String expected = "-1" + getDecimalCharacter() + "23 - 1" + getDecimalCharacter() + "43i";
    78          String actual = complexFormat.format(c);
    79          assertEquals(expected, actual);
    80  	}
    81
    82  	public void testZeroReal() {
    83  		Complex c = new Complex(0.0, -1.4343);
    84          String expected = "0 - 1" + getDecimalCharacter() + "43i";
    85          String actual = complexFormat.format(c);
    86          assertEquals(expected, actual);
    87  	}
    88
    89  	public void testZeroImaginary() {
    90  		Complex c = new Complex(30.233, 0);
    91          String expected = "30" + getDecimalCharacter() + "23";
    92          String actual = complexFormat.format(c);
    93          assertEquals(expected, actual);
    94  	}
    95
    96  	public void testDifferentImaginaryChar() {
    97  		Complex c = new Complex(1, 1);
    98          String expected = "1 + 1j";
    99          String actual = complexFormatJ.format(c);
    100         assertEquals(expected, actual);
    101 	}
    102
    103 	public void testStaticFormatComplex() {
    104         Locale defaultLocal = Locale.getDefault();
    105         Locale.setDefault(getLocale());
    106
    107 		Complex c = new Complex(232.222, -342.33);
    108         String expected = "232" + getDecimalCharacter() + "22 - 342" + getDecimalCharacter() + "33i";
    109         String actual = ComplexFormat.formatComplex(c);
    110         assertEquals(expected, actual);
    111
    112         Locale.setDefault(defaultLocal);
    113 	}
    114
    115 	public void testNan() {
    116 		Complex c = new Complex(Double.NaN, Double.NaN);
    117         String expected = "(NaN) + (NaN)i";
    118         String actual = complexFormat.format(c);
    119         assertEquals(expected, actual);
    120 	}
    121
    122 	public void testPositiveInfinity() {
    123 		Complex c = new Complex(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
    124         String expected = "(Infinity) + (Infinity)i";
    125         String actual = complexFormat.format(c);
    126         assertEquals(expected, actual);
    127 	}
    128
    129 	public void testNegativeInfinity() {
    130 		Complex c = new Complex(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
    131         String expected = "(-Infinity) - (Infinity)i";
    132         String actual = complexFormat.format(c);
    133         assertEquals(expected, actual);
    134 	}
    135
    136     public void testParseSimpleNoDecimals() {
    137         String source = "1 + 1i";
    138         Complex expected = new Complex(1, 1);
    139         try {
    140             Complex actual = (Complex)complexFormat.parseObject(source);
    141             assertEquals(expected, actual);
    142         } catch (ParseException ex) {
    143             fail(ex.getMessage());
    144         }
    145     }
    146
    147     public void testParseSimpleWithDecimals() {
    148         String source = "1" + getDecimalCharacter() + "23 + 1" + getDecimalCharacter() + "43i";
    149         Complex expected = new Complex(1.23, 1.43);
    150         try {
    151             Complex actual = (Complex)complexFormat.parseObject(source);
    152             assertEquals(expected, actual);
    153         } catch (ParseException ex) {
    154             fail(ex.getMessage());
    155         }
    156     }
    157
    158     public void testParseSimpleWithDecimalsTrunc() {
    159         String source = "1" + getDecimalCharacter() + "2323 + 1" + getDecimalCharacter() + "4343i";
    160         Complex expected = new Complex(1.2323, 1.4343);
    161         try {
    162             Complex actual = (Complex)complexFormat.parseObject(source);
    163             assertEquals(expected, actual);
    164         } catch (ParseException ex) {
    165             fail(ex.getMessage());
    166         }
    167     }
    168
    169     public void testParseNegativeReal() {
    170         String source = "-1" + getDecimalCharacter() + "2323 + 1" + getDecimalCharacter() + "4343i";
    171         Complex expected = new Complex(-1.2323, 1.4343);
    172         try {
    173             Complex actual = (Complex)complexFormat.parseObject(source);
    174             assertEquals(expected, actual);
    175         } catch (ParseException ex) {
    176             fail(ex.getMessage());
    177         }
    178     }
    179
    180     public void testParseNegativeImaginary() {
    181         String source = "1" + getDecimalCharacter() + "2323 - 1" + getDecimalCharacter() + "4343i";
    182         Complex expected = new Complex(1.2323, -1.4343);
    183         try {
    184             Complex actual = (Complex)complexFormat.parseObject(source);
    185             assertEquals(expected, actual);
    186         } catch (ParseException ex) {
    187             fail(ex.getMessage());
    188         }
    189     }
    190
    191     public void testParseNegativeBoth() {
    192         String source = "-1" + getDecimalCharacter() + "2323 - 1" + getDecimalCharacter() + "4343i";
    193         Complex expected = new Complex(-1.2323, -1.4343);
    194         try {
    195             Complex actual = (Complex)complexFormat.parseObject(source);
    196             assertEquals(expected, actual);
    197         } catch (ParseException ex) {
    198             fail(ex.getMessage());
    199         }
    200     }
    201
    202     public void testParseZeroReal() {
    203         String source = "0" + getDecimalCharacter() + "0 - 1" + getDecimalCharacter() + "4343i";
    204         Complex expected = new Complex(0.0, -1.4343);
    205         try {
    206             Complex actual = (Complex)complexFormat.parseObject(source);
    207             assertEquals(expected, actual);
    208         } catch (ParseException ex) {
    209             fail(ex.getMessage());
    210         }
    211     }
    212
    213     public void testParseZeroImaginary() {
    214         String source = "-1" + getDecimalCharacter() + "2323";
    215         Complex expected = new Complex(-1.2323, 0);
    216         try {
    217             Complex actual = (Complex)complexFormat.parseObject(source);
    218             assertEquals(expected, actual);
    219         } catch (ParseException ex) {
    220             fail(ex.getMessage());
    221         }
    222     }
    223
    224     public void testParseDifferentImaginaryChar() {
    225         String source = "-1" + getDecimalCharacter() + "2323 - 1" + getDecimalCharacter() + "4343j";
    226         Complex expected = new Complex(-1.2323, -1.4343);
    227         try {
    228             Complex actual = (Complex)complexFormatJ.parseObject(source);
    229             assertEquals(expected, actual);
    230         } catch (ParseException ex) {
    231             fail(ex.getMessage());
    232         }
    233     }
    234
    235     public void testParseNan() {
    236         String source = "(NaN) + (NaN)i";
    237         Complex expected = new Complex(Double.NaN, Double.NaN);
    238         try {
    239             Complex actual = (Complex)complexFormat.parseObject(source);
    240             assertEquals(expected, actual);
    241         } catch (ParseException ex) {
    242             fail(ex.getMessage());
    243         }
    244     }
    245
    246     public void testParsePositiveInfinity() {
    247         String source = "(Infinity) + (Infinity)i";
    248         Complex expected = new Complex(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
    249         try {
    250             Complex actual = (Complex)complexFormat.parseObject(source);
    251             assertEquals(expected, actual);
    252         } catch (ParseException ex) {
    253             fail(ex.getMessage());
    254         }
    255     }
    256
    257     public void testPaseNegativeInfinity() {
    258         String source = "(-Infinity) - (Infinity)i";
    259         Complex expected = new Complex(Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY);
    260         try {
    261             Complex actual = (Complex)complexFormat.parseObject(source);
    262             assertEquals(expected, actual);
    263         } catch (ParseException ex) {
    264             fail(ex.getMessage());
    265         }
    266     }
    267
    268     public void testConstructorSingleFormat() {
    269         NumberFormat nf = NumberFormat.getInstance();
    270         ComplexFormat cf = new ComplexFormat(nf);
    271         assertNotNull(cf);
    272         assertEquals(nf, cf.getRealFormat());
    273     }
    274
    275     public void testGetImaginaryFormat() {
    276         NumberFormat nf = NumberFormat.getInstance();
    277         ComplexFormat cf = new ComplexFormat();
    278
    279         assertNotSame(nf, cf.getImaginaryFormat());
    280         cf.setImaginaryFormat(nf);
    281         assertSame(nf, cf.getImaginaryFormat());
    282     }
    283
    284     public void testSetImaginaryFormatNull() {
    285         try {
    286             ComplexFormat cf = new ComplexFormat();
    287             cf.setImaginaryFormat(null);
    288             fail();
    289         } catch (IllegalArgumentException ex) {
    290             // success
    291         }
    292     }
    293
    294     public void testSetRealFormatNull() {
    295         try {
    296             ComplexFormat cf = new ComplexFormat();
    297             cf.setRealFormat(null);
    298             fail();
    299         } catch (IllegalArgumentException ex) {
    300             // success
    301         }
    302     }
    303
    304     public void testGetRealFormat() {
    305         NumberFormat nf = NumberFormat.getInstance();
    306         ComplexFormat cf = new ComplexFormat();
    307
    308         assertNotSame(nf, cf.getRealFormat());
    309         cf.setRealFormat(nf);
    310         assertSame(nf, cf.getRealFormat());
    311     }
    312
    313     public void testSetImaginaryCharacterNull() {
    314         try {
    315             ComplexFormat cf = new ComplexFormat();
    316             cf.setImaginaryCharacter(null);
    317             fail();
    318         } catch (IllegalArgumentException ex) {
    319             // success
    320         }
    321     }
    322
    323     public void testSetImaginaryCharacterEmpty() {
    324         try {
    325             ComplexFormat cf = new ComplexFormat();
    326             cf.setImaginaryCharacter("");
    327             fail();
    328         } catch (IllegalArgumentException ex) {
    329             // success
    330         }
    331     }
    332
    333     public void testFormatNumber() {
    334         ComplexFormat cf = ComplexFormat.getInstance(getLocale());
    335         Double pi = new Double(Math.PI);
    336         String text = cf.format(pi);
    337         assertEquals("3" + getDecimalCharacter() + "14", text);
    338     }
    339
    340     public void testFormatObject() {
    341         try {
    342             ComplexFormat cf = new ComplexFormat();
    343             Object object = new Object();
    344             cf.format(object);
    345             fail();
    346         } catch (IllegalArgumentException ex) {
    347             // success
    348         }
    349     }
    350 }